C++ Operator Overloading

Operator Overloading is generalization of function overloading. It increases the readability of our code. Further, it is straightforward and natural way to extend C++.

General form of operator overloading:

C++ operator overloading

 

 

Return type may be whatever the operator returns including a reference to the object of the operand. Operator symbol may be any overloadable operator from the list.

 

Overloading Unary Operators

Unary Operators can overload as

  • Non-static member function with no arguments.
  • As a global function with one argument. Argument must be class object or reference to class object.

Why non-static?

  1. static functions only access static data
  2. Not what is needed for operator functions

Overloading ++ and –

  • Pre/post-incrementing/decrementing operators can be overloaded
  • How does the compiler distinguish between the two?

Prefix versions overloaded same as any other prefix unary operator would be. i.e. d1.operator++(); for ++d1;

Postfix versions can be overloaded with integer argument. Prototype: Date::operator++( int ); For d1++;

The following program is example for unary operator overloading.

//example
//overloading unary operator for prefix and postfix
#include<iostream>
using namespace std;
class Counter
{
private:
    unsigned int count;
public:
    Counter()                           // constructor
    {
        count = 0;
    }
    int get_count() const
    {
        return count;
    }
    Counter operator ++ ()              // increment (prefix)
    {
        ++count;
        return *this;
    }
    Counter operator ++ (int)           //increment(postfix)
    {
        Counter tmp=*this;              //save old value
        ++count;                        //update value r
        return tmp;                     //return original
    }
};
int main()
{
    Counter c1, c2,c3;                  // define and initialize
    ++c1;                               // increment c1
    ++c2;                               // increment c2
    c3=c2++;                            // increment c2
    cout << "\n c1=" << c1.get_count();  // displays 1
    cout << "\n c2=" << c2.get_count();  // displays 2
    cout << "\n c3=" << c3.get_count();  //displays 1; assigned before increase
}

The output of the program is:

c1 = 1 
c2 = 2 
c3 = 1

 

Overloading Binary Operator

Binary operators can be overloaded just like unary operators. Arithmetic operators, comparison operators, and arithmetic assignment operators can be overloaded.

If binary operator is overloaded with a non-static member function, it needs one argument.

Syntax:

class class_name { 
    public: 
        return_type operator operator_symbol (class_name args); 
            //… 
}; 
return_type class_name::operator operator_symbol(class_name args) { 
    //… 
}

Here is example program that adds two complex numbers.

//overloading binary operator
#include<iostream>
using namespace std;
class complex
{
private:
    float real, imag;
public:
    complex () {}
    complex (float r, float i)
    {
        real=r;
        imag=i;
    }
    void display()
    {
        cout<<"("<<real<<","<<imag<<")";
    }
    complex operator + (complex);
};
complex complex:: operator + (complex c)
{
    complex temp;
    temp.real= real +c.real;
    temp.imag=imag +c. imag;
    return temp;
}
int main()
{
    complex c1(4.4,3.6), c2(1.8,1.06), c3;
    c3=c1+c2;
    c1.display();
    cout<<" + ";
    c2.display();
    cout<< " = ";
    c3.display();
}

The output of the program is:

(4.4, 3.6) + (1.8, 1.06) = ( 6.2, 4.66)

 

If binary operator is overloaded with a global function, then it requires with two arguments: One argument must be class object or reference to a class object.

Syntax:

class class_name { 
    public: 
        return_type operator operator_symbol (class_name args); 
            //… 
}; 
return_type class_name::operator operator_symbol(class_name obj1,class_name obj2) { 
    //… 
}
C++ Arrays
C++ Data Conversion