Unit 4
What are Pointers?
In C++, a pointer refers to a variable that holds the address of another variable. Like
regular variables, pointers have a data type. For example, a pointer of type integer
can hold the address of a variable of type integer. A pointer of character type can
hold the address of a variable of character type.
You should see a pointer as a symbolic representation of a memory address. With
pointers, programs can simulate call-by-reference. They can also create and
manipulate dynamic data structures. In C++, a pointer variable refers to a variable
pointing to a specific address in a memory pointed by another variable.
Pointer Declaration Syntax
The declaration of C++ takes the following syntax:
datatype *variable_name;
The datatype is the base type of the pointer which must be a valid C+
+ data type.
The variable_name is should be the name of the pointer variable.
Asterisk used above for pointer declaration is similar to asterisk used
to perform multiplication operation. It is the asterisk that marks the
variable as a pointer.
Here is an example of valid pointer declarations in C++:
int *x; // a pointer to integer
double *x; // a pointer to double
float *x; // a pointer to float
char *ch // a pointer to a character
Reference operator (&) and Deference operator
(*)
The reference operator (&) returns the variable’s address.
The dereference operator (*) helps us get the value that has been stored in
a memory address.
For example:
If we have a variable given the name num, stored in the address 0x234 and
storing the value 28.
The reference operator (&) will return 0x234.
The dereference operator (*) will return 5.
Example 1:
#include <iostream>
using namespace std;
int main() {
int x = 27;
int *ip;
ip = &x;
cout << "Value of x is : ";
cout << x << endl;
cout << "Value of ip is : ";
cout << ip<< endl;
cout << "Value of *ip is : ";
cout << *ip << endl;
return 0;
}
Output:
How this works:
C++ Pointer Arithmetic
As you understood pointer is an address which is a numeric value; therefore, you
can perform arithmetic operations on a pointer just as you can a numeric value.
There are four arithmetic operators that can be used on pointers: ++, --, +, and -
To understand pointer arithmetic, let us consider that ptr is an integer pointer which
points to the address 1000. Assuming 32-bit integers, let us perform the following
arithmetic operation on the pointer −
ptr++
the ptr will point to the location 1004 because each time ptr is incremented, it will
point to the next integer. This operation will move the pointer to next memory
location without impacting actual value at the memory location. If ptr points to a
character whose address is 1000, then above operation will point to the location
1001 because next character will be available at 1001.
Incrementing a Pointer
We prefer using a pointer in our program instead of an array because the variable
pointer can be incremented, unlike the array name which cannot be incremented
because it is a constant pointer. The following program increments the variable
pointer to access each succeeding element of the array −
Live Demo
#include <iostream>
using namespace std;
const int MAX = 3;
int main () {
int var[MAX] = {10, 100, 200};
int *ptr;
// let us have array address in pointer.
ptr = var;
for (int i = 0; i < MAX; i++) {
cout << "Address of var[" << i << "] = ";
cout << ptr << endl;
cout << "Value of var[" << i << "] = ";
cout << *ptr << endl;
// point to the next location
ptr++;
}
return 0;
}
When the above code is compiled and executed, it produces result something as
follows −
Address of var[0] = 0xbfa088b0
Value of var[0] = 10
Address of var[1] = 0xbfa088b4
Value of var[1] = 100
Address of var[2] = 0xbfa088b8
Value of var[2] = 200
Decrementing a Pointer
The same considerations apply to decrementing a pointer, which decreases its
value by the number of bytes of its data type as shown below −
Live Demo
#include <iostream>
using namespace std;
const int MAX = 3;
int main () {
int var[MAX] = {10, 100, 200};
int *ptr;
// let us have address of the last element in pointer.
ptr = &var[MAX-1];
for (int i = MAX; i > 0; i--) {
cout << "Address of var[" << i << "] = ";
cout << ptr << endl;
cout << "Value of var[" << i << "] = ";
cout << *ptr << endl;
// point to the previous location
ptr--;
}
return 0;
}
When the above code is compiled and executed, it produces result something as
follows −
Address of var[3] = 0xbfdb70f8
Value of var[3] = 200
Address of var[2] = 0xbfdb70f4
Value of var[2] = 100
Address of var[1] = 0xbfdb70f0
Value of var[1] = 10
Pointer Comparisons
Pointers may be compared by using relational operators, such as ==, <, and >. If p1
and p2 point to variables that are related to each other, such as elements of the
same array, then p1 and p2 can be meaningfully compared.
The following program modifies the previous example one by incrementing the
variable pointer so long as the address to which it points is either less than or equal
to the address of the last element of the array, which is &var[MAX - 1] −
Live Demo
#include <iostream>
using namespace std;
const int MAX = 3;
int main () {
int var[MAX] = {10, 100, 200};
int *ptr;
// let us have address of the first element in pointer.
ptr = var;
int i = 0;
while ( ptr <= &var[MAX - 1] ) {
cout << "Address of var[" << i << "] = ";
cout << ptr << endl;
cout << "Value of var[" << i << "] = ";
cout << *ptr << endl;
// point to the previous location
ptr++;
i++;
}
return 0;
}
When the above code is compiled and executed, it produces result something as
follows −
Address of var[0] = 0xbfce42d0
Value of var[0] = 10
Address of var[1] = 0xbfce42d4
Value of var[1] = 100
Address of var[2] = 0xbfce42d8
Value of var[2] = 200
Using Pointers with Objects
A pointer to a C++ class is done exactly the same way as a pointer to a structure and
to access members of a pointer to a class you use the member access operator ->
operator, just as you do with pointers to structures. Also as with all pointers, you
must initialize the pointer before using it.
For accessing normal data members we use the dot . operator with
object and -> qith pointer to object. But when we have a pointer to
data member, we have to dereference that pointer to get what its
pointing to, hence it becomes,
Object.*pointerToMember
Copy
and with pointer to object, it can be accessed by writing,
ObjectPointer->*pointerToMember
Lets take an example, to understand the complete concept.
class Data
{
public:
int a;
void print()
{
cout << "a is "<< a;
}
};
int main()
{
Data d, *dp;
dp = &d; // pointer to object
int Data::*ptr=&Data::a; // pointer to data member 'a'
d.*ptr=10;
d.print();
dp->*ptr=20;
dp->print();
}
Output:
a is 10
a is 20
C++ this Pointer
In C++ programming, this is a keyword that refers to the current instance of the
class. There can be 3 main usage of this keyword in C++.
o It can be used to pass current object as a parameter to another method.
o It can be used to refer current class instance variable.
o It can be used to declare indexers.
C++ this Pointer Example
Let's see the example of this keyword in C++ that refers to the fields of current class.
1. #include <iostream>
2. class Employee {
3. public:
4. int id; //data member (also instance variable)
5. string name; //data member(also instance variable)
6. float salary;
7. Employee(int id, string name, float salary)
8. {
9. this->id = id;
10. this->name = name;
11. this->salary = salary;
12. }
13. void display()
14. {
15. cout<<id<<" "<<name<<" "<<salary<<endl;
16. }
17. };
18. int main() {
19. Employee e1 =Employee(101, "Sonoo", 890000); //creating an object of Em
ployee
20. Employee e2=Employee(102, "Nakul", 59000); //creating an object of Emplo
yee
21. e1.display();
22. e2.display();
23. return 0;
24. }
Output:
101 Sonoo 890000
102 Nakul 59000
Pointer to Derived Class
In C++, we can declare a pointer points to the base class as well as derive class.
Consider below example to understand pointer to derived class
#include<iostream.h>
class base
{
public:
int n1;
void show()
{
cout<<”\nn1 = “<<n1;
}
};
class derive : public base
{
public:
int n2;
void show()
{
cout<<”\nn1 = “<<n1;
cout<<”\nn2 = “<<n2;
}
};
int main()
{
base b;
base *bptr; //base pointer
cout<<”Pointer of base class points to it”;
bptr=&b; //address of base class
bptr->n1=44; //access base class via base pointer
bptr->show();
derive d;
cout<<”\n”;
bptr=&d; //address of derive class
bptr->n1=66; //access derive class via base pointer
bptr->show();
return 0;
}
Output
Pointer of base class points to it
n1 = 44
Pointer of base class points to derive class
n1=66
Here the show() method is the overridden method, bptr execute show() method of ‘base’ class
twice and display its content. Even though bptr first points to ‘base’ and second time points to
‘derive’ ,both the time bptr->show() executes the ‘base’ method show()
C++ Polymorphism
The term "Polymorphism" is the combination of "poly" + "morphs" which means many
forms. It is a greek word. In object-oriented programming, we use 3 main concepts:
inheritance, encapsulation, and polymorphism.
Real Life Example Of Polymorphism
Let's consider a real-life example of polymorphism. A lady behaves like a teacher in a
classroom, mother or daughter in a home and customer in a market. Here, a single person is
behaving differently according to the situations.
There are two types of polymorphism in C++:
o Compile time polymorphism: The overloaded functions are invoked by matching
the type and number of arguments. This information is available at the compile time
and, therefore, compiler selects the appropriate function at the compile time. It is
achieved by function overloading and operator overloading which is also known as
static binding or early binding. Now, let's consider the case where function name and
prototype is same.
1. class A // base class declaration.
2. {
3. int a;
4. public:
5. void display()
6. {
7. cout<< "Class A ";
8. }
9. };
10. class B : public A // derived class declaration.
11. {
12. int b;
13. public:
14. void display()
15. {
16. cout<<"Class B";
17. }
18. };
In the above case, the prototype of display() function is the same in both the base
and derived class. Therefore, the static binding cannot be applied. It would be great
if the appropriate function is selected at the run time. This is known as run time
polymorphism.
o Run time polymorphism: Run time polymorphism is achieved when the
object's method is invoked at the run time instead of compile time. It is
achieved by method overriding which is also known as dynamic binding or
late binding.
Differences b/w compile time and run time
polymorphism.
Compile time polymorphism Run time polymorphism
The function to be invoked is known at the The function to be invoked is known
compile time. at the run time.
It is also known as overloading, early It is also known as overriding,
binding and static binding. Dynamic binding and late binding.
Overloading is a compile time Overriding is a run time
polymorphism where more than one polymorphism where more than one
method is having the same name but with method is having the same name,
the different number of parameters or the number of parameters and the type
type of the parameters. of the parameters.
It is achieved by function overloading and It is achieved by virtual functions and
operator overloading. pointers.
It provides fast execution as it is known at It provides slow execution as it is
the compile time. known at the run time.
It is less flexible as mainly all the things It is more flexible as all the things
execute at the compile time. execute at the run time.
C++ Runtime Polymorphism Example
Let's see a simple example of run time polymorphism in C++.
// an example without the virtual keyword.
1. #include <iostream>
2. using namespace std;
3. class Animal {
4. public:
5. void eat(){
6. cout<<"Eating...";
7. }
8. };
9. class Dog: public Animal
10. {
11. public:
12. void eat()
13. { cout<<"Eating bread...";
14. }
15. };
16. int main(void) {
17. Dog d = Dog();
18. d.eat();
19. return 0;
20. }
1. Compile Time Polymorphism
In compile-time polymorphism, a function is called at the time of program compilation.
We call this type of polymorphism as early binding or Static binding.
Function overloading and operator overloading is the type of Compile time
polymorphism.
I. Function Overloading
Function overloading means one function can perform many tasks. In C++, a single
function is used to perform many tasks with the same name and different types of
arguments. In the function overloading function will call at the time of program
compilation. It is an example of compile-time polymorphism.
In the below example, A function ADD() is used to perform two tasks. The two asks
would be to add two integer values and add two strings (concatenate).
Readability of the program increases by function overloading. It is achieved by using the
same name for the same action.
Source Code:
1 #include <iostream>
2 using namespace std;
class Addition {
3
public:
4
5 int ADD(int X,int Y) // Function with parameter
6 {
7 return X+Y; // this function is performing addition of two Integer val
8 }
9 int ADD() { // Function with same name but without parameter
string a= "HELLO";
10
string b="SAM"; // in this function concatenation is performed
11
string c= a+b;
12
cout<<c<<endl;
13
14
}
15
};
16 int main(void) {
17 Addition obj; // Object is created
18 cout<<obj.ADD(128, 15)<<endl; //first method is called
19 obj.ADD(); // second method is called
return 0;
20
}
21
22
Output
143
HELLOSAM
In the above example, we use function ADD() to perform many tasks which is a property
of polymorphism in C++.
II. Operator Overloading
Operator overloading means defining additional tasks to operators without changing its
actual meaning. We do this by using operator function.
The purpose of operator overloading is to provide a special meaning to the user-defined
data types.
The advantage of Operators overloading is to perform different operations on the same
operand.
Source Code
1 #include <iostream>
2 using namespace std;
class A
3
{
4
5
string x;
6
public:
7
A(){}
8 A(string i)
9 {
10 x=i;
11 }
12 void operator+(A);
void display();
13
};
14
15
void A:: operator+(A a)
16
{
17
18
string m = x+a.x;
19
cout<<"The result of the addition of two objects is : "<<m;
20
21
22
}
23 int main()
24 {
25 A a1("Welcome");
26 A a2("back");
27 a1+a2;
return 0;
28
}
29
30
Output
The result of the addition of two objects is: Welcomeback
2. Runtime Polymorphism
In a Runtime polymorphism, functions are called at the time the program execution.
Hence, it is known as late binding or dynamic binding.
Function overriding is a part of runtime polymorphism. In function overriding, more than
one method has the same name with different types of the parameter list.
It is achieved by using virtual functions and pointers. It provides slow execution as it is
known at the run time. Thus, It is more flexible as all the things executed at the run time.
I. Function overriding
In function overriding, we give the new definition to base class function in the derived
class. At that time, we can say the base function has been overridden. It can be only
possible in the ‘derived class’. In function overriding, we have two definitions of the
same function, one in the superclass and one in the derived class. The decision about
which function definition requires calling happens at runtime. That is the reason we call
it ‘Runtime polymorphism’.
Source code
1
2 #include <iostream>
3 using namespace std;
4 class Animal {
public:
5
void function(){
6
cout<<"Eating..."<<endl;
7
}
8
};
9 class Man: public Animal
10 {
11 public:
12 void function()
13 {
cout<<"Walking ..."<<endl;
14
}
15
};
16
int main(void) {
17
Animal A =Animal();
18
A.function(); //parent class object
19 Man m = Man();
20 m.function(); // child class object
21
22 return 0;
23 }
24
Output
Eating …..
Walking……
II. Virtual Function
A virtual function is declared by keyword virtual. The return type of virtual function may
be int, float, void.
A virtual function is a member function in the base class. We can redefine it in a derived
class. It is part of run time polymorphism. The declaration of the virtual function must be
in the base class by using the keyword virtual. A virtual function is not static.
The virtual function helps to tell the compiler to perform dynamic binding or late binding
on the function.
If it is necessary to use a single pointer to refer to all the different classes’ objects. This is
because we will have to create a pointer to the base class that refers to all the derived
objects.
But, when the base class pointer contains the derived class address, the object always
executes the base class function. For resolving this problem, we use the virtual function.
When we declare a virtual function, the compiler determines which function to invoke at
runtime.
Let’s see the below example for understanding how the program execution happens
without virtual function and with virtual function.
Source code
1 //without virtual Function
2
4
#include <iostream>
5
using namespace std;
6
class Add
7
{
8
int x=5, y=20;
9
public:
10 void display() //overridden function
11 {
12 cout << "Value of x is : " << x+y<<endl;
13 }
14 };
class Substract: public Add
15
{
16
int y = 10,z=30;
17
public:
18
void display() //overridden function
19 {
20 cout << "Value of y is : " <<y-z<<endl;
21 }
22 };
23 int main()
{
24
Add *m; //base class pointer .it can only access the base class memb
25
Substract s; // making object of derived class
26
m = &s;
27
m->display(); // Accessing the function by using base class pointer
28 return 0;
29 }
30
Output
Value of x is: 25
Virtual Function used to invoke the derived class in a program.
Source Code
1 #include<iostream>
2 using namespace std;
3
class Add
4
{
5
public:
6
virtual void print ()
7
{ int a=20, b=30;
8 cout<< " base class Action is:"<<a+b <<endl;
9 }
10
11 void show ()
12 { cout<< "show base class" <<endl; }
13 };
14
class Sub: public Add
15
{
16
public:
17
void print () //print () is already virtual function in derived class, we could
18
{ int x=20,y=10;
19
20
cout<< " derived class Action:"<<x-y <<endl; }
21
22 void show ()
23 { cout<< "show derived class" <<endl; }
24
25
};
26
27
//main function
28
int main()
29 {
30 Add *aptr;
31 Sub s;
32 aptr = &s;
33
34 //virtual function, binded at runtime (Runtime polymorphism)
aptr->print();
35
36
// Non-virtual function, binded at compile time
37
aptr->show();
38
39
return 0;
40
}
41
42
Output
derived class Action:10
Pure virtual Function
When the function has no definition, we call such functions as “Do-nothing function or
Pure virtual function”. The declaration of this function happens in the base class with no
definition.
Source Code
1 #include <iostream>
2 using namespace std;
3 class Animal
4 {
5 public:
6 virtual void show() = 0; //Pure virtual function declaration.
7 };
8 class Man: public Animal
9 {
10 public:
11 void show()
12 {
13 cout << "Man is the part of animal husbandry " << endl;
14 }
15 };
16 int main()
17 {
18 Animal *aptr; //Base class pointer
19 //Animal a;
20 Man m; //derived class object creation.
21 aptr = &m;
22 aptr->show();
23 return 0;
24 }
Unary Operator Overloading:
Q. Write a C++ program to overload unary operators that is increment and decrement.
Answer:
Operator overloading is a type of polymorphism in which an operator is overloaded to give user
defined meaning to it. It is used to perform operation on user-defined data type.
Following program is overloading unary operators: increment (++) and decrement (--).
#include<iostream>
using namespace std;
class IncreDecre
{
int a, b;
public:
void accept()
{
cout<<"\n Enter Two Numbers : \n";
cout<<" ";
cin>>a;
cout<<" ";
cin>>b;
}
void operator--() //Overload Unary Decrement
{
a--;
b--;
}
void operator++() //Overload Unary Increment
{
a++;
b++;
}
void display()
{
cout<<"\n A : "<<a;
cout<<"\n B : "<<b;
}
};
int main()
{
IncreDecre id;
id.accept();
--id;
cout<<"\n After Decrementing : ";
id.display();
++id;
++id;
cout<<"\n\n After Incrementing : ";
id.display();
return 0;
}
Output:
Binary Operator Overloading
As the name suggests, those operators which operate on two operands or data are called binary
operators.
Here is an example to show how binary operators are overloaded in C++.
Example: C++ program to illustrate binary operator overloading
#include<iostream>
using namespace std;
class complex
{
private:
int real,imag;
public:
void getvalue()
{
cout<<"Enter the value of real number:";
cin>>real;
cout<<"Enter the value of imaginary number:";
cin>>imag;
}
complex operator+(complex obj)
{
complex temp;
temp.real=real+obj.real;
temp.imag=imag+obj.imag;
return(temp);
}
complex operator-(complex obj)
{
complex temp;
temp.real=real-obj.real;
temp.imag=imag-obj.imag;
return(temp);
}
void display()
{
cout<<real<<"+"<<"("<<imag<<")"<<"i"<<"\n";
}
};
int main()
{
complex c1,c2,c3,c4;
c1.getvalue();
c2.getvalue();
c3 = c1+c2;
c4 = c1-c2;
cout<<"Result is:\n";
c3.display();
c4.display();
return 0;
}
