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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...