There are various ways to overload Operators in C++ by implementing any of the following types of functions:
1) Member Function
2) Non-Member Function
3) Friend Function
List of operators that can be overloaded are:
+ |
– |
* |
? |
% |
? |
& |
| |
~ |
! |
= |
< |
> |
+= |
-= |
*= |
?= |
%= |
?= |
&= |
|= |
<< |
>> |
<<= |
>>= |
== |
!= |
<= |
>= |
&& |
|| |
++ |
— |
, |
->* |
-> |
( ) |
[ ] |
new |
delete |
new[] |
delete[] |
|
Example 1: Overloading ++ Operator
// CPP program to illustrate // operators that can be overloaded #include <iostream> using namespace std;
class overload {
private :
int count;
public :
overload()
: count(4)
{
}
void operator++() { count = count + 1; }
void Display() { cout << "Count: " << count; }
}; int main()
{ overload i;
// this calls "function void operator ++()" function
++i;
i.Display();
return 0;
} |
Count: 5
This function is called when the ++ operator operates on the object of the overload class (object i in this case). In the program, void operator ++ () operator function is defined (inside overload class). This function increments the value of count by 1 for i object.
Example 2: Overloading ++ operator i.e. pre and post increment operator
// CPP program to demonstrate the // Difference between pre increment // and post increment overload operator #include <iostream> using namespace std;
class overload {
private :
int count;
public :
overload( int i)
: count(i)
{
}
overload operator++( int ) { return (count++); }
overload operator++()
{
count = count + 1;
return count;
}
void Display() { cout << "Count: " << count << endl; }
}; // Driver code int main()
{ overload i(5);
overload post(5);
overload pre(5);
// this calls "function overload operator ++()" function
pre = ++i;
cout << "results of I = " ;
i.Display();
cout << "results of preincrement = " ;
pre.Display();
// this call "function overload operator ++()"function
i++; // just to show diff
i++; // just to show diff
post = i++;
cout << "Results of post increment = " ;
post.Display();
cout << "And results of i , here we see difference : "
" " ;
i.Display();
return 0;
} |
results of I = Count: 6 results of preincrement = Count: 6 Results of post increment = Count: 8 And results of i , here we see difference : Count: 9
Example 3: Overloading [ ] operator
// CPP program to illustrate overloading the // [ ] operator #include <iostream> using namespace std;
class overload {
int a[3];
public :
overload( int i, int j, int k)
{
a[0] = i;
a[1] = j;
a[2] = k;
}
int operator[]( int i) { return a[i]; }
}; int main()
{ overload ob(1, 2, 3);
cout << ob[1]; // displays 2
return (0);
} |
2
Example 4 : Overloading -> operator
// CPP program to illustrate // operators that can be overloaded #include <bits/stdc++.h> using namespace std;
class GFG {
public :
int num;
GFG( int j) { num = j; }
GFG* operator->( void ) { return this ; }
}; // Driver code int main()
{ GFG T(5);
GFG* Ptr = &T;
// Accessing num normally
cout << "T.num = " << T.num << endl;
// Accessing num using normal object pointer
cout << "Ptr->num = " << Ptr->num << endl;
// Accessing num using -> operator
cout << "T->num = " << T->num << endl;
return 0;
} |
T.num = 5 Ptr->num = 5 T->num = 5
List of operators that cannot be overloaded
1) Scope Resolution Operator (::)
2) Ternary or Conditional Operator (?:)
3) Member Access or Dot operator (.)
4) Pointer-to-member Operator (.*)
5) Object size Operator (sizeof)
6) Object type Operator(typeid)
7) static_cast (casting operator)
8) const_cast (casting operator)
9) reinterpret_cast (casting operator)
10) dynamic_cast (casting operator)
Example 5: Overloading this .(dot) operator
Dot (.) operator can’t be overloaded, so it will generate an error.
// C++ program to illustrate // Overloading this .(dot) operator #include <iostream> using namespace std;
class cantover {
public :
void fun();
}; class X {
cantover* p;
cantover& operator.() { return *p; }
void fun();
}; void g(X& x)
{ x.fun(); // X::fun or cantover::fun or error?
} |
Output: Error
prog.cpp:12:23: error: expected type-specifier before ‘.’ token cantover& operator.() { return *p; }
This program will generate an error. Similarly, the above operators will also generate an error, if overloaded.