Pointers

• Variables are used to hold data values during the

execution of a program.
• Every variable when declared occupies certain
memory locations.
• It is also possible to access and display the address
of the memory location of variable using &
operator with variable name.
• The pointer variable is needed to store the address
of any varaible.
• The pointer is denoted by * asterisk symbol.
• A pointer is a memory variable that stores a
memory address.
 Features of Pointers

• Pointers save the memory space.

• Execution time with pointer is faster because data
is manipulated with the address i.e. direct access to
memory location.
• Dynamically memory is allocated.
• Pointers are used with data structures. They are
useful for representing 2D and Multi-D array.
 Pointer variable
• A pointer is a variable that contains the memory
location of another variable.
• Syntax:-
• type * variable name
• You start by specifying the type of data stored in the
location identified by the pointer.
• The asterisk tells the compiler that you are creating a
pointer variable.
• Finally you give the name of the variable.
 (Pointer Declaration)

• int *x;
• float *f;
• char *c;
• In the first declaration x is an integer pointer it tells the
compiler that it holds address of any integer variable.
• Similarly float pointer and character pointer.
• The indirection operator (*) also called deference
operator
• When a pointer is dereference, the value at that
address stored by the pointer is retrieved.
• The indirection operator is used for two distinct
purpose with pointer declaration and deference.
 Declaring a Pointer Variable

 To declare ptr as an integer pointer:

int *ptr;
 To declare ptr as a character pointer:
char *ptr;
 Accessing a variable through its
pointer
• Once we declare a pointer variable we must point it
to something. We can do this by assigning to the
pointer the address of the variable you want to
point as in the following example:
ptr=#
• This places the address where num is stores into the
variable ptr. If num is stored in memory 21260
address then the variable ptr has the value 21260.
 Address and Pointers
• Memory can be
conceptualized as a ADDR1 Contents1
linear set of data ADDR2
ADDR3
locations. ADDR4
ADDR5
• Variables reference the ADDR6
*
contents of a locations *
*
• Pointers have a value of
ADDR11 Contents11
the address of a given
location *
*

ADDR16 Contents16

Lect 14 P. 10
 Pointer Variable
Assume ptr is a pointer variable and x is an integer variable

x 10

ptr &x

Now ptr can access the value of x.

HOW!!!!
x = 10
Write: *variable . For example:

ptr = &x Cout<< *ptr;

 Pointers(Operations on Pointers)

• Arithmetic operations are also possible using

pointes.
• Addition
• Subtraction
• Multiplication
• Division
• Prefix and post fix operations
• A number can be added to a pointer or addition of
two variables through pointer is possible.
• A number can be subtracted from a pointer or
subtraction of two variables through pointer is
possible.
• Multiplication of two pointers or a multiplication of
number with pointer is also possible.
• Similarly for division and mod opeartions
• Addition of two addresses is not possible
• Multiplication of two addresses is not possible.
• Division of two addresses is not possible.
 Increment and decrement
Data Type Initial address Operation Address after Required bytes
operation s
Int i=2 4046 ++ -- 4048 4044 2bytes
Char c=‘x’ 4053 ++ -- 4054 4052 1bytes
Float f=2.2 4050 ++ -- 4054 4046 4bytes
Long l=2 4060 ++ -- 4064 4056 4bytes
Diagrammatic representation
 Variables, Addresses and Pointers

• main() • Memory Value

{ • a (1001) 5
int a = 5; • b (1003) 6
int b = 6; • c (1005) 1001
int *c;
// c points to a
c = &a;
}
 Assignment in pointers

• Pointer variables can be "assigned":

int *p1, *p2;
p2 = p1;
– Assigns one pointer to another
– "Make p2 point to where p1 points"
• Do not confuse with:
*p1 = *p2;
– Assigns "value pointed to" by p1, to "value
pointed to" by p2
 (Pointer and 1D array)

• Array name by itself is an address or pointer. It

points to the address of the first element. The
elements of the array together with their addresses
can be displayed by using array name.
 Pointers(Pointers and
Multidimensional Array)
Pointers(Array of Pointers)
Pointers(Passing pointer to a function)
 include< stdio.h >
{
int num, *intptr;
float x, *floptr;
char ch, *cptr;
num=123;
x=12.34;
ch=’a’;
intptr=&num;
cptr=&ch;
floptr=&x;
cout<<“Num “<<*intptr,<<“ stored at address “<<intptr;
cout<<“Value “<<*floptr <<“ stored at address “<<floptr;
cout<<“Character <<*cptr <<“stored at address”<<cptr;
}
 Run this code

int main()
{
int x;
int *ptr;

x = 10;
ptr = &x;
*ptr = *ptr + 1;
cout<< x;
return 0;
}
 Constant Pointers

• A constant pointer, ptr, is a pointer that is

initialized with an address, and cannot point to
anything else.
• We can use ptr to change the contents of
value
• Example
int value = 22;
int * const ptr = &value;

25
CIS 15 Pointer
Arithmetic
 Constant Pointer
 Constant pointer means the pointer is constant.
Constant pointer is NOT pointer to constant.
 For eg:
int * const ptr2 indicates that ptr2 is a pointer
which is constant. This means that ptr2 cannot be
made to point to another integer.
 However the integer pointed by ptr2 can be
changed.
 //const pointer void
main()
{
int i = 100,k;
int* const pi = &i;
*pi = 200;
pi=&k; //won't compile
}
 Constant Pointers to Constants

 A constant pointer to a constant is:

a pointer that points to a constant
a pointer that cannot point to anything except what it is
pointing to

 Example:
int value = 22;
const int * const ptr = &value;

28
CIS 15 Pointer
Arithmetic
//const pointer to a const void
f3()
{
int i = 100;
const int* const pi = &i;
//*pi = 200; <- won't compile
//pi++; <- won't compile
}
 Pointer to constant

Pointer to constant is
const int * ptr1 indicates that ptr1 is a pointer that
points to a constant integer. The integer is constant
and cannot be changed. However, the pointer ptr1
can be made to point to some other integer.
• //pointer to a const
void f1()
{
int i = 100;
const int* pi = &i;
//*pi = 200; <- won't compile
pi++;
}
 Pointer arithmetic

Valid operations on pointers include:

- the sum of a pointer and an integer
- the difference of a pointer and an
integer
- pointer comparison
-the difference of two pointers.
-Increment/decrement in pointers
- assignment operator used in pointers
 Example
void main()
{
int a=25,b=78,sum;
int *x,*y;
x=&a;
y=&b;
sum= *x + *y;
cout<<“Sum is : ”<<sum;
}
 Comparison in pointers
• Two pointers of the same type, p and q, may be
compared as long
• as both of them point to objects within a single memory
block
• • Pointers may be compared using the <, >, <=, >=, == , !
=
• • When you are comparing two pointers, you are
comparing the
• values of those pointers rather than the contents of
memory locations pointed to by these pointers
• You can perform a limited number of arithmetic operations on pointers.
These operations are:
• Increment and decrement
• Addition and subtraction
• Comparison
• Assignment
• The increment (++) operator increases the value of a pointer by the size of
the data object the pointer refers to. For example, if the pointer refers to
the second element in an array, the ++ makes the pointer refer to the third
element in the array.
• The decrement (--) operator decreases the value of a pointer by the size of
the data object the pointer refers to. For example, if the pointer refers to
the second element in an array, the -- makes the pointer refer to the first
element in the array.
• You can add an integer to a pointer but you cannot add a pointer to a
pointer.
• If the pointer p points to the first element in an array, the following
expression causes the pointer to point to the third element in the same
array:
• p = p + 2; If you have two pointers that point to the same array, you can
subtract one pointer from the other. This operation yields the number of
elements in the array that separate the two addresses that the pointers
refer to.
• You can compare two pointers with the following operators: ==, !=, <, >, <=,
and >=.
• Pointer comparisons are defined only when the pointers point to elements
of the same array. Pointer comparisons using the == and != operators can be
performed even when the pointers point to elements of different arrays.
• You can assign to a pointer the address of a data object, the value of
another compatible pointer or the NULL pointer.
 Pointer Arithmetic
• Operations on pointer variables:
Operation Example
int vals[]={4,7,11};
int *valptr = vals;
++, -- valptr++; // points at 7
valptr--; // now points at 4
+, - (pointer and int) cout << *(valptr + 2); // 11

+=,-= (pointer and int) valptr = vals; // points at 4

valptr += 2; // points at 11

37
CIS 15 Pointer
Arithmetic
 Void pointers
• When a variable is declared as being a pointer to
type void it is known as a generic pointer.
• Since you cannot have a variable of type void, the
pointer will not point to any data and therefore
cannot be dereferenced.
• It is still a pointer though, to use it you just have to
typecast it to another kind of pointer first. Hence
the term Generic pointer.
• This is very useful when you want a pointer to point
to data of different types at different times.

• Syntax:
void * variable name;

Print value stored in variable

*(data_type*)name of variable;
void main()
{ int i;
char c;
void *data;
i = 6;
c = 'a';
data = &i;
cout<<"the_data points to the integer value “<< *(int*) data;
data = &c;
cout<<"the_data now points to the character “<< *(char*) data;
}
 Null Pointer

• NULL value can be assigned to any pointer, no

matter what its type.
void *p = NULL;
int i = 2;
int *ip = &i;
p = ip;
cout<<*p;
cout<<*((int*)p ) ;
 Pointers and Arrays

The concept of array is very much bound to the one

of pointer. In fact, the identifier of an array is
equivalent to the address of its first element, as a
pointer is equivalent to the address of the first
element that it points to, so in fact they are the
same concept.
 Pointers and Arrays

• Pointers have close relationship with array .

• An array name by itself is an address or pointer.
• Pointers are linked with both types of array
– A)one dimensional array pointer
– B)two dimensional array pointer
For example,
int numbers [20]; int * p;

The following assignment operation would be valid:

p = numbers;
After that, p and numbers would be equivalent and would
have the same properties. The only difference is that
we could change the value of pointer p by another one,
whereas numbers will always point to the first of the 20
elements of type int with which it was defined.
Therefore, unlike p, which is an ordinary pointer,
numbers is an array, and an array can be considered a
constant pointer.
#include <iostream.h>
main ()
{ int numbers[5];
int * p;
p = numbers;
*p = 10;
p++;
*p = 20;
p = &numbers[2];
Cont…
…cont.

*p = 30;
p = numbers + 3;
*p = 40; p = numbers;
*(p+4) = 50;
for (int n=0; n<5; n++)
cout<<numbers[n];
}
In arrays we used brackets ([]) several times in
order to specify the index of an element of the
array to which we wanted to refer. Well, these
bracket sign operators [] are also a dereference
operator known as offset operator. They
dereference the variable they follow just as *
does, but they also add the number between
brackets to the address being dereferenced
For example:
a[5] = 0; // a [offset of 5] = 0
*(a+5) = 0; // pointed by (a+5) = 0

These two expressions are equivalent and valid

both if a is a pointer or if a is an array.
 Example of 1D array
Void main()
{
int a[5]={1,2,3,4,5};
int *p,i;
p=&a;
cout<<“displaying data using pointer ”;
for(i=0;i<5;i++)
{
cout<<*(p+i);
}
cout<<“displaying data using array name ”;
for(i=0;i<5;i++)
{
cout<<*(a+i);
}
}
 Example of 2D array
Void main()
{
int a[5][2]={ {1,2},{3,4},{5,6},{7,8},{9,10} };
int *p,j,i;
p=&a;
cout<<“displaying data using pointer ”;
for(i=0;i<5;i++)
{
for(j=0;i<2;j++)
{
cout<<*(*(a+i)+j);
}
cout<<“\n”;
}
}
Pointers and Character String
void main()
{
char name[] = “sanjima”;
char *ptr;
int i=0;count=0;
ptr=&name;
while(*(ptr+i)!=‘\0’)
{
count++;
i++;
}
cout<<“length of string is ”<<count;
getch();
}
 Example
void main()
{
char str1[]=“hello”;
char str2[10];
char *s= “Good Morning”;
char *q;

str2=str1; /error/
q= s; /works/
return;
}
 Array of pointers
• It is nothing but a collection of address.
Void main()
{
int a[5]={1,2,3,4,5},i;
int *p[5];
for(i=0;i<5;i++)
{
p[i]=a+i;
}
for(i=0;i<5;i++)
{
cout<<*(p+i)<<“value”;
cout<<“at location ”<<p+I;
}
}
 Pointers to pointers
• A pointer variable containing address of another
pointer variable is called pointer to pointer
void main()
{
int a=2, *p, **q;
p=&a;
q=&p;
cout<<a<<“is stored at ”<<p<<“and pointer is
stored at ”<<q;}
Difference between *p[3] and (*p)[3]

*p[3] declares p as an array of 3 pointers

(*p)[3] declares p as a pointer to an array of 3

elements
• *(p+2)
 What is this pointer?

• Every object has a special pointer "this" which

points to the object itself.
• This pointer is accessible to all members of the
class but not to any static members of the class.
• Can be used to find the address of the object in
which the function is a member.
• Presence of this pointer is not included in the sizeof
calculations.
class MyClass {
int data;
public:
MyClass() {data=100;};
void Print1();
void Print2();
};
// Not using this pointer
void MyClass::Print1() {
cout << data << endl;
}

// Using this pointer

void MyClass::Print2() {
cout << "My address = " << this << endl;
cout << this->data << endl;
}
int main()
{
MyClass a;
a.Print1();
a.Print2();

// Size of doesn't include this pointer

cout << sizeof(a) << endl;
}
OUTPUT:
100
My address = 0012FF88
100
4
 Pointer to derived class object

Class base1
{
Public:
Void display()
{
Cout<<“base class displayed”;
}
};
Class der1:public base1
{
Public:
Void display()
{cout<<“derived class displayed”;}
};
Void main()
{
base1 *ptr;
der1 d;
ptr=&d;
ptrdisplay();
getch()
}
Output
Base class displayed
 Virtual function

• It is the member function declared in the base class

using the key word virtual. whose functionality
redefined in the derived class.
Class base1
{
Public:
Virtual Void display()
{
Cout<<“base class displayed”;
}
};
Class der1:public base1
{
Public:
Void display()
{cout<<“derived class displayed”;}
};
Void main()
{
base1 *ptr;
der1 d;
ptr=&d;
ptrdisplay();
getch()
}
Output
derived class displayed
Pure Virtual Function
• Is a function without a body
• Is created by adding the notation ‘=0’ to the
virtual function declaration
• Example:
virtual int calc_net_salary()=0;
class shape
{
protected:
int a,b;
public:
void read()
{
cin>>a>>b;
}
virtual void cal_area()=0;
};
class rectangle:public shape class triangle:public shape
{ {
void cal_area() void cal_area()
{ {
doubles area=a*b; doubles area=(a*b)/2;
cout<<area; cout<<area;
} }
}; };
int main()
{
shape *ptr[2];
rectangle r1;
cout<<“enter leng n bredth”;
r1.read();
triangle t1;
cout<<“enter base n perpendicular”;
t1.read();
prt[0]=&r1;
ptr[1]=&t1;
for(int i=0;i<2;i++)
ptr[i]->cal_area();
}
Enter leng and breadth 10 20
Enter base and perpendicular 5 20
Area of rectangle=200
Area of trinagle=50