New Tutorials:

Arithmetic operator are most commonly used operator in C++. Almost all arithmetic operator can be overloaded to perform arithmetic operation on user-defined data type. In the below example we have overridden the + operator, to add to Time(hh:mm:ss) objects.

### Example: overloading `+` Operator to add two Time class object

``````#include <iostream.h>
#include <conio.h>
class Time
{
int h,m,s;
public:
Time()
{
h=0, m=0; s=0;
}
void setTime();
void show()
{
cout<< h<< ":"<< m<< ":"<< s;
}

Time operator+(time);
};

Time Time::operator+(Time t1)	//operator function
{
Time t;
int a,b;
a = s+t1.s;
t.s = a%60;
b = (a/60)+m+t1.m;
t.m = b%60;
t.h = (b/60)+h+t1.h;
t.h = t.h%12;
return t;
}

void time::setTime()
{
cout << "\n Enter the hour(0-11) ";
cin >> h;
cout << "\n Enter the minute(0-59) ";
cin >> m;
cout << "\n Enter the second(0-59) ";
cin >> s;
}

void main()
{
Time t1,t2,t3;

cout << "\n Enter the first time ";
t1.setTime();
cout << "\n Enter the second time ";
t2.setTime();
t3 = t1 + t2;	//adding of two time object using '+' operator
cout << "\n First time ";
t1.show();
cout << "\n Second time ";
t2.show();
cout << "\n Sum of times ";
t3.show();
getch();
}
``````

While normal addition of two numbers return the sumation result. In the case above we have overloaded the `+` operator, to perform addition of two `Time` class objects. We add the seconds, minutes and hour values separately to return the new value of time.

In the `setTime()` funtion we are separately asking the user to enter the values for hour, minute and second, and then we are setting those values to the `Time` class object.

For inputs, `t1` as 01:20:30(1 hour, 20 minute, 30 seconds) and `t2` as 02:15:25(2 hour, 15 minute, 25 seconds), the output for the above program will be:

1:20:30 2:15:25 3:35:55

First two are values of `t1` and `t2` and the third is the result of their addition.

The first question before learning how to override the I/O operator should be, why we need to override the I/O operators. Following are a few cases, where overloading the I/O operator proves useful:

• We can overload output operator `<<` to print values for user defined datatypes.
• We can overload output operator `>>` to input values for user defined datatypes.

In case of input/output operator overloading, left operand will be of types `ostream&` and `istream&`

Also, when overloading these operators, we must make sure that the functions must be a Non-Member function because left operand is not an object of the class.

And it must be a friend function to access private data members.

You have seen above that `<<` operator is overloaded with ostream class object `cout` to print primitive datatype values to the screen, which is the default behavious of `<<` operator, when used with `cout`. In other words, it is already overloaded by default.

Similarly we can overload `<<` operator in our class to print user-defined datatypes to screen. For example we can overload `<<` in our `Time` class to display the value of `Time` object using `cout` rather than writing a custom member function like `show()` to print the value of `Time` class objects.

``````Time t1(3,15,48);
// like this, directly
cout << t1;``````

In the next section we will learn how to do that.

NOTE: When the operator does not modify its operands, the best way to overload the operator is via friend function.

### Example: overloading `<<` Operator to print Class Object

We will now overload the `<<` operator in the `Time` class,

``````#include<iostream.h>
#include<conio.h>
class Time
{
int hr, min, sec;
public:
// default constructor
Time()
{
hr=0, min=0; sec=0;
}

Time(int h, int m, int s)
{
hr=h, min=m; sec=s;
}

friend ostream& operator << (ostream &out, Time &tm);
};

ostream& operator << (ostream &out, Time &tm)
{
out << "Time is: " << tm.hr << " hour : " << tm.min << " min : " << tm.sec << " sec";
return out;
}

void main()
{
Time tm(3,15,45);
cout << tm;
}
``````

Time is: 3 hour : 15 min : 45 sec

This is simplied in languages like Core Java, where all you need to do in a class is override the `toString()` method of the `String` class, and you can define how to print the object of that class.

You can also overload relational operators like ` == `, ` != `, ` >= ` , ` <= ` etc. to compare two object of any class.

Let's take a quick example by overloading the `==` operator in the `Time` class to directly compare two objects of `Time` class.

``````class Time
{
int hr, min, sec;
public:
// default constructor
Time()
{
hr=0, min=0; sec=0;
}

Time(int h, int m, int s)
{
hr=h, min=m; sec=s;
}

friend bool operator==(Time &t1, Time &t2);
};

/*
Here we are simply comparing the hour, minute and
second values of two different Time objects to compare
their values
*/
bool operator== (Time &t1, Time &t2)
{
return ( t1.hr == t2.hr && t1.min == t2.min && t1.sec == t2.sec );
}

void main()
{
Time t1(3,15,45);
Time t2(4,15,45);
if(t1 == t2)
{
cout << "Both the time values are equal";
}
else
{
cout << "Both the time values are not equal";
}
}
``````

Both the time values are not equal

As the hour value of object `t1` is 3 and for object `t2` it is 4, hence they are not equal.

## Copy Constructor vs. Assignment Operator (`=`)

Assignment operator is used to copy the values from one object to another already existing object. For example:

``````Time tm(3,15,45); // tm object created and initialized
Time t1;    // t1 object created
t1 = tm;    // initializing t1 using tm
``````

Whereas, Copy constructor is a special constructor that initializes a new object from an existing object.

``````Time tm(3,15,45); // tm object created and initialized
Time t1(tm);    //t1 object created and initialized using tm object
``````

In case of Copy constructor, we provide the object to be copied as an argument to the constructor. Also, we first need to define a copy constructor in our class. We have covered Copey constructor in detail here: Copy Constructor in C++