What are the Operators that Can be and Cannot be Overloaded in C++?
Last Updated :
27 May, 2022
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
#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;
++i;
i.Display();
return 0;
}
|
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
#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; }
};
int main()
{
overload i(5);
overload post(5);
overload pre(5);
pre = ++i;
cout << "results of I = " ;
i.Display();
cout << "results of preincrement = " ;
pre.Display();
i++;
i++;
post = i++;
cout << "Results of post increment = " ;
post.Display();
cout << "And results of i , here we see difference : "
" " ;
i.Display();
return 0;
}
|
Output
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
#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];
return (0);
}
|
Example 4 : Overloading -> operator
CPP
#include <bits/stdc++.h>
using namespace std;
class GFG {
public :
int num;
GFG( int j) { num = j; }
GFG* operator->( void ) { return this ; }
};
int main()
{
GFG T(5);
GFG* Ptr = &T;
cout << "T.num = " << T.num << endl;
cout << "Ptr->num = " << Ptr->num << endl;
cout << "T->num = " << T->num << endl;
return 0;
}
|
Output
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.
CPP
#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();
}
|
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.
Share your thoughts in the comments
Please Login to comment...