CHAPTER 6

POINTER
Out line
 Pointer declaration

 Pointer operation

 Pointers and arrays

 Calling a function by reference

INTRODUCTION TO POINTERS
 When we declare a variable some memory is allocated for it. The
memory location can be referenced through the identifier “i”.
 Thus, we have two properties for any variable : its address and its
data value. The address of the variable can be accessed through the
referencing operator “&”. “&i” gives the memory location where
the data value for “i” is stored.

 A pointer variable is one that stores an address. We can declare

pointers as follows int* p; .This means that p stores the address of a
variable of type int.
 Pointer is the variable that stores the address of an other variable.
 POINTERS
 As you can see in the example below, integer takes four byte of space, short
(short integer) takes two bytes of space and char takes only one byte of space.
The address is also consecutive.
 POINTER VARIABLE

 Declaration of Pointer variables

type* pointer_name;
//or
type *pointer_name;
where type is the type of data pointed, not the type of the pointer itself. (e.g. int,
char, double)

Examples:
int *n;
double *r;
int **p; // pointer to pointer
int *p1, *p2, v1, v2; p1 and p2 point to variables of type int v1 and v2 are
variables of type int .
 POINTER VARIABLES
Memory address: 1020 1024 1032

… 88 100 … 1024 …
a p
int a = 100; Result is:
int *p = &a; 100 1024
cout << a << " " << &a <<endl; 1024 1032
cout << p << " " << &p <<endl;

 The value of pointer p is the address of variable a

 A pointer is also a variable, so it has its own memory address
 The address of Operator
 The & operator can be used to determine the address of a variable
which can be assigned to a pointer variable.

Example: int *p1,v1;

p1=&v1;
 p1 is now a pointer to v1. v1 can be called "the variable pointed
by p1".

The dereferencing Operator

 Here the * is the dereferencing operator. The phrase "The variable
pointed to by p" is translated into C++ as *p. *and & are inverses
-they cancel each other out.
 EXAMPLE 2:
#include <iostream>
using namespace std;
int main()
{
int *p1,v1;
v1=0;
p1=&v1;//v1 and *p1 now refer to the same variable
*p1 = 42;
cout <<v1<<endl;
cout <<*p1<<endl;
cout <<&v1<<endl;
cout <<p1<<endl;
return 0;
}
Output of the above program but do not forget that the memory address
differs:
42
42
0x6dfef8
0x6dfef8
EXAMPLE 3:
#include<iostream>
using namespace std;
int main() {
int value1 = 5, value2 = 15;
int * mypointer;
mypointer = &value1;
*mypointer = 10;
mypointer = &value2;
*mypointer = 20;
cout <<"value1=="<<value1<<"/
value2=="<< value2;

return 0;
}
Output of the above program:
value1==10/value2==20
 ARITHMETIC OF POINTERS
 Only addition and subtraction operations are allowed to be
conducted.
 But both addition and subtraction have a different behavior with
pointers according to the size of the data type to which they point
to.
 When we saw the different data types that exist, we saw that some
occupy more or less space than others in the memory.
 For example, in the case of integer numbers, int occupies 4 byte,
char occupies 1 byte, short occupies 2 bytes and long occupies 4.
 CONT…
 Let's suppose that we have 3 pointers: char *mychar; short
*myshort; long *mylong; and let us assume that they point to
memory locations 1000, 2000 and 3000 respectively. So if we
write: mychar++;

myshort++;

mylong++;
 mychar, as you may expect, would contain the value 1001.
 myshort would contain the value 2002, and
 mylong would contain 3004.
CONT…
EXAMPLE 4:
#include <iostream>
using namespace std;
int main()
{
short myshort1 = 2;
int mylong1 = 45;
short *myshort = &myshort1;
int *mylong = &mylong1;
cout << myshort << endl;
cout << mylong << endl;
myshort++;
mylong++;
cout << myshort << endl;
cout << mylong << endl;
return 0;
}
Output
0x6dfef6
0x6dfef0
0x6dfef8
0x6dfef4
 CONT..
 If the address of x is 2000, then after statement p=p-3; then the value of p is
1988 (as the size of int is 4, when we subtract 3 integers, we have to multiply it
with 4 which 4*3 = 12). Look the following example
#include<iostream>
using namespace std;
int main() {
float x=9,*p;
p=&x;
cout <<p<<endl;
p=p-3;
cout <<p;
return 0;
}
Output
0x6dfee8
0x6dfedc
Pointers to Pointers
 A pointer to a value that is itself a pointer can be declared using
multiple levels of * symbols.

char a;

char *b;

char **c;

a='z';

b=&a;

c=&b;
 Supposing random memory locations 7230, 8092 and 10502, could
be described thus:
void * Pointers
A void pointer can reference any type of value.
double d;
int f;
double * dp = & d; //legal
dp=&f; //illegal because dp is double whereas f is int.
void * p = dp; //legal, p can hold all data types
P=&d; //legal
p=&f; //legal
However, when we assign a void * parameter like p, it must always
be cast (changed) before it can be used:
double * dp2;
dp2 = (double *)p; // convert p back into pointer to double because p
is void * type.
Pointers and Arrays
 The identifier of an array is equivalent to the address of its first
element.
int num [20];
int * p;
 The following allocation would be valid:
p = num;
 you can also say:
p=&num[0];
 At this point p and numbers are equivalent. The only difference
that we could assign another value to the pointer p whereas
numbers will always point to the first of the 20 integer numbers of
type int with which it was defined. So, unlike p, that is an ordinary
variable pointer, numbers is a constant pointer (indeed that is an
Array: a constant pointer). The following allocation is not valid:
numbers = p; because numbers is an array (constant pointer), and no
values can be assigned to constant identifiers.
EXAMPLE:
#include<iostream>
using namespace std;
int main() {
int numbers[5];
int * p;
p = numbers;
*p = 10;
p++;
*p = 20;
p = &numbers[2];
*p = 30;
p = numbers + 3;
*p = 40;
p = numbers;
*(p+4) = 50;
for(int n=0; n<5; n++)
cout <<numbers[n]<<",";
}
Output of the above program:
10, 20, 30, 40, 50,
EXAMPLE 2:
#include<iostream>
using namespace std;
int main() {
int a[5]={5,6,3,2,9};
int *p;
p=&a[0];
for(int i=0;i<=4;i++)
cout <<*(p+i)<<" ";
return 0;
}
Output of the above program:
56329
Array name is pointer. Therefore, the above program can be written as:
#include<iostream>
using namespace std;
int main() {
int a[5]={5,6,3,2,9};
for(int i=0;i<=4;i++)
cout <<*(a+i)<<" ";
return 0;
}
 Pointer and String
 We know strings are array of characters. Therefore, pointer
notation can be applied to the characters in strings.
 But in the case of string if we initialize the string at the time of
declaration, the string name is constant.
 Therefore, we cannot perform pointer arithmetic operation with
that.
See the following example:
#include<iostream>
using namespace std;
int main() {
char str[]="dawed nesru";
cout <<str;
str++; //illegal
return 0;
}
The program does not have an output because of line 6:
#include<iostream>
using namespace std;
int main() {
char *str=“abebe maru";
cout <<str<<endl;
str++;
cout <<str;
return 0;
}
Output of the above program:
Abebe maru
bebe maru
POINTER AND STRUCTURE
READING ASSIGNMENT ???
 U
Y O
N K
A Q ?
T H