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