Unit 4: Operator Overloading [7hrs]
Fundamentals of Operator overloading
It is one of the important features of C++ language.
C++ has the ability to provide the operators with a special meaning for a data type. The
mechanism of giving such special meanings to an operator is known as operator overloading.
Operator overloading provides a flexible option for the creation of new definitions for most
of the C++ operators.
We can overload (give additional meaning to) all the C++ operators except the following:
class member access operators (.)
Scope resolution operator (::)
Size of operator (sizeof)
Conditional operator (?)
Operator overloading is done with the help of special function called “operator” function.
Defining operator overloading:
return –type class name :: operator op (arg_list)
{
Function body
}
Here,
op = operator being overloaded
1. Overloading unary minus ( - ) operator:
#include<iostream>
using namespace std;
class space
{
int x;
int y;
int z;
public:
void getdata (int a, int b, int c);
void display (void);
void operator - (); // overloaded unary minus
};
void space:: getdata (int a, int b, int c)
{
x = a;
y = b;
z = c;
1
}
void space :: display (void)
{
cout <<x<< " " ;
cout << y << " " ;
cout<< z << "\n" ;
}
void space :: operator - () // here operator is a keyword
{
x = -x;
y = -y;
z = -z;
}
int main ()
{
space s;
s.getdata (10, -20, 30);
cout << "S:";
s.display();
-s; // activates operator-() function
cout << "S:";
s.display ();
}
Output:
S: 10 -20 30
S: -10 20 -30
2. Overloading binary operator:
Example 1
# include<iostream>
using namespace std;
class complex
{
float x;
float y;
public:
complex () {}
complex (float real, float imag)
{
x = real; y = imag;
}
complex operator + (complex);
void display();
2
};
complex complex :: operator + (complex c)
{
complex temp;
temp.x = x + c.x;
temp.y = y + c.y;
return (temp);
}
void complex :: display (void)
{
cout<< x << "+j" <<y<<"\n";
}
int main ()
{
complex C1, C2, C3; // invokes constructor1
C1 = complex (2.5,3.5); // invokes constructor 2
C2 = complex (1.6, 2.7);
C3 = C1 + C2; // activates operator + () function
cout<<"C1= " ; C1.display();
cout<<"C2= " ; C2.display();
cout<<"C3= "; C3.display ();
}
Output:
C1 = 2.5 + j3.5
C2 = 1.6 + j2.7
C3 = 4.1 + j6.2
Example 2
#include<iostream>
using namespace std;
class overloading
{
int value;
public:
void setValue(int temp)
{ value = temp; }
overloading operator+(overloading ob)
{
overloading t;
t.value=value+ob.value;
return(t);
}
void display()
{
cout<<"\n Value is :"<<value<<endl;
3
}
};
int main()
{
overloading obj1,obj2,result;
int n;
cout<<"Enter the no of terms";
cin>>n;
for(int i=1;i<=n;i++)
{ cout<<i<<" Run\n";
obj1.setValue(i);
obj2.setValue(i);
result = obj1 + obj2;
result.display();
}
return 0;
}
Output
Data Conversion
Type conversion refers to changing an entity of one data type, expression, function agreement or
return value into another.
1) Basic to Basic
#include<iostream>
4
using namespace std;
int main()
{
float b = 4.4;
int c;
c = (int)b;
cout<<c;
return 0;
}
2) Basic to user-defined
#include<iostream>
using namespace std;
class X
{
int z;
char y;
public:
X() { }
X (char p)
{
z = (int)p;
y = p;
}
void show()
{
cout<<z<<y;
}
};
int main ()
{
char s = 'a';
X x1;
x1 = s; // calls parameterized constructor. 's' is basic type and x1 is class type.
x1.show();
return 0;
}
3) User-defined to Basic
#include<iostream>
5
#include<math.h>
using namespace std;
class Hour
{
int hr;
public:
Hour() { }
operator int()
{
int minute;
minute= hr * 60;
return (minute);
}
void getdata()
{
cout<<"Enter Hours";
cin>>hr;
}
};
int main()
{
Hour h1;
float min;
h1.getdata();
min = h1; //user defined type to basic
cout<<"Minutes = "<<min;
}
4) User -defined to User-defined
a) Class type to Class type conversion using constructor in the destination class: Rectangle to Polar
#include<iostream>
#include<math.h>
using namespace std;
class rectangle
{ float x,y;
public:
rectangle(float a, float b)
{ x=a;
6
y=b;
float get_x()
{ return(x);
float get_y()
{ return(y);
};
class polar
{ float radius,thita;
public:
void show();
polar(){ }
polar(rectangle r)
{ float tempx=r.get_x();
float tempy=r.get_y();
radius = sqrt(tempx*tempx + tempy*tempy);
thita = atan(tempy/tempx);
};
void polar :: show()
{ cout<<"radius is:"<<radius<<endl;
cout<<"thita is:"<<thita*(180/3.14);
int main()
7
rectangle r(6,9);
polar p(r);
p.show();
return 0;
b) Polar to rectangle conversion using casting operator in source class.
/* Polar to rectangle using casting operator */
#include<iostream>
#include<math.h>
#define PI 3.141592654
using namespace std;
class rectangle //destination class
{
float x;
float y;
public:
rectangle(){ }
rectangle(float a, float b)
{ x=a;
y=b;
}
void show()
{
cout<<"x="<<x<<" "<<"y="<<y;
}
};
class polar //source class
{ float radius;
float thita;
public:
polar(){ radius =0.0,thita=0.0;}
polar(float r,float t)
{ radius= r;
thita= t;
8
}
operator rectangle() {
double a= radius * cos(thita);
double b= radius * sin(thita);
return(rectangle(a,b));
}
void show()
{
cout<<"radius is="<<radius<<" and "<<"thita="<<thita;
}
};
int main()
{
rectangle r1;
polar p1(10.8167,56.338*PI/180);
r1=p1;
cout<<"\npolar coordinate"<<endl;
p1.show();
cout<<"\n\nRectangle coordiante "<<endl;
r1.show();
return 0;
}
