Skip to main content

Operator Overloading

What is operator overloading?

Operator overloading is the process of customizing C++ operators for operands of user defined types.
 
When you have two objects of a class- num1 and num2, you can write a function to add them such as  

 ans = add(num1,num2);

That does not look neither simple nor intuitive.

You would prefer to write 
    
 ans = num1+num2;

as you would write expressions for basic data types like integers, floats etc. 
 
This can be done using Operator overloading.

Operator overloading lets you write such statements. That is, it lets you call your functions on objects using  +, - ,* etc. 
 
+ operator will call addition function on the object (when you write op. overloading function for +). * will call multiply on objects etc.

Names of overloaded operator functions start with keyword operator followed by  symbol of the operator. e.g. +, - etc.

Unary operator functions take 0 parameters for members. The operand for these function is the object calling the function. 
 
Binary member operator functions take one parameter. First operand of these is the object calling the function and the second operand is the parameter of function.

Let us look at a simple Integer class with overloaded + and += operators.
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
 
class Integer
{
 int num;
 public:
 Integer(int n=0); 
 Integer operator +(Integer a);
 void operator +=(Integer a);
};
Integer::Integer(int n):num(n)
{} 
Integer Integer::operator +(Integer a) 
{
 return Integer(num+a.num);
}
void Integer::operator +=(Integer a)
{
 num+=a.num;
}
 
Look at the function in line 11. The name of the function is operator +.  
 
And the function takes one argument of the type Integer. The function adds the num  of invoking object ( this->num) and num of parameter object and returns Integer object with the sum of the two.

You can call this overloaded function as shown below.
 
int main()
{
 Integer obj1(10),obj2(5),obj3;
 obj3 = obj1+obj2; 
 /*obj3.num will be 15*/
}


obj3=obj1+obj2;      this line calls + operator function for obj1, takes obj2 as a parameter a and assigns the returned object to obj3.
 
The other overloaded operator in the program above  is +=.  This takes one operand and modifies the current object. You can call this function as shown below.
 
 obj2+=obj1; /*obj2.num is obj1.num+obj2.num. obj1 is not modified*/
 
Some points must be remembered while overloading the operators
    1. You can overload operators as member functions or non-member friend functions.
    2. There are some operators which can not be overloaded at all e.g. ::(scope resolution), .(member) , ?:(ternary),sizeof,.*
    3. When overloading operators, unary operators must remain unary and binary operators must remain binary.
      • Binary operator function if it is member function, takes one parameter.
      • Binary operator non-member function takes 2 parameters.
      • Unary operator member takes no parameters and unary non-member operator function takes one parameter.
    4. You can NOT create a new operators of your own.
 

Remember that binary operator function takes a hidden operand and the hidden operand is the current object (*this) and will be the first operand.

      obj3 = obj1+obj2;

In the line above, obj1 is treated as *this, obj2 is the parameter because the line is equivalent to
       obj3 = obj1.operator+(obj2);

Similarly if the operator is unary, member operator function does not take any parameters, as the only operand will be the current object.

The situation is different if you use a non-member function. For non-member  functions, unary operators take exactly one parameter and binary operators take exactly two parameters.

For the sake of completeness, let us rewrite our + operator as friend, non-member friend function. 
 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
 
class Integer
{
 int num;
 public:
 Integer(int n=0);
 int getNum();
 void setNum(int n);
 friend Integer operator +(Integer a,Integer b);//friend + operator
 void operator +=(Integer a);
};
Integer operator +(Integer a, Integer b) //non-member operator function
{ 
 return Integer(a.num+b.num);
}
 

Notice that in line 11, we do not say Integer::operator+. Instead we say operator +. The function is not a member of class Integer, it is just a friend.

As the operator function is friend, it can access private data and functions of Integer class.

A non-member operator function can also be non-friend and access the members with the help of  getters and setters of the class. 

For more such notes, programs and quiz, download Simplified C++ by Hegdeapps 


Labels:

Comments

Post a Comment

Popular posts from this blog

Ten questions in C/C++

Let us see some questions in C and C++ Write printf statement in C to print - I got 98% in Maths Can you execute a function before main() in C? If yes, how is it done? Can you write a program to find if a number is even without using modulo operator? How do you define a data member which is common to all objects of a class in C++? Can we have a single constructor for a class, but still create objects from the class passing zero/one and two parameters? What problems might occur if a class has no default constructor? Is the following statement correct? fprintf(stdout,"Hello world");   Why do we use the following statement in C++ program? using namespace std;  Can you write a single statement to check if the number is a power of 2?  What does the following statement mean in C/C++?4 if(a) b++;    So we have 10 questions. How many of these can you answer?   Do you need more questions in C and C++?    You can find t...
Post a Comment
Read more

It is a constant

In good old days, C programmers would use preprocessor directive to define constants. e.g. #define s 10 But we know now that, as compiler never gets to see these, preprocessor statements are error prone. Hence we have const s. A constant - defined with keyword const promises that this entity is never going to change. And if we accidentally modify a const, compiler throws an error. Let us look at an example. #include<iostream> using namespace std; int main () { int a = 10 ; const int b = 12 ; a ++ ; b = 18 ; } When we compile this program, compiler tells us that default.cpp: In function ‘int main()’: default.cpp:8:7: error: assignment of read-only variable ‘b’      b = 18; So it is catching the error that we are trying to modify a const. Whenever a local variable or parameter need not be modified, declare it as a const.  Yes, we can make even parameters as constant. We can make objects constant or even me...
Post a Comment
Read more

Abstract class

 If we can not create any objects of a class, then it is called an abstract class. A class is made abstract by adding at least one pure virtual function to it. Pure virtual function A function is said to be a pure virtual function , if it has no definition but has only declaration. Pure virtual function is defined with the keyword virtual and followed by return type, function name and "=0". class Shape { public: virtual void printarea() =0 ; }; int main () { Shape obj1; //error } Here printarea() function of Shape class is a pure virtual function as it has no body. To make a function as pure virtual function, you should use =0 at the end of virtual function declaration Abstract class When a class has at least one pure virtual function, it is incomplete and no objects can be created from that class. Such a class is called an abstract class . In the earlier example class Shape is an abstract class, and objects can not be created from t...
Post a Comment
Read more