What are the operators that can be and cannot be overloaded in C++?

List of operators that can be overloaded are:

+    -    *    /      %        ^
&    |    ~    !,        =
    =      ++        --
    ==    !=      &&        ||
+=    -=    /=    %=      ^=        &=
|=    *=    =      []        ()
->    ->*    new    new []      delete    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; 
} 

Output:

Count: 5

This function is called when ++ operator operates on the object of 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 and overloading postincrement operator

// this program will demonstrate  
// Difference between pre increment and post 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;  
}  

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 this [ ] 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); 
} 

Output:

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; 
} 
// Thank you Rohan Agarwal for suggesting this example. 

Output :

T.num = 5
Ptr->num = 5
T->num = 5

List of operators that cannot be overloaded

1> Scope Resolution Operator  (::)    
2> Pointer-to-member Operator (.*)    
3> Member Access or Dot operator  (.)    
4> Ternary or Conditional Operator (?:) 
5> Object size Operator   (sizeof) 
6> Object type Operator   (typeid)

Example 5 : Overloading this .(dot) operator

Dot (.) operator can’t be overloaded, so it cause error.

// C++ program to illustrate 
// Overloading this .(dot) operator 
#include <iostream> 
#include <iostream> 
class cantover { 
public: 
    void fun(); 
}; 
class X { // assume that you can overload . 
    cantover* p; 
    cantover& operator.() 
    { 
        return *p; 
    } 
    void fun(); 
}; 
void g(X& x) 
{ 
    x.fun(); // X::fun or cantover::fun or error? 
} 

Output

prog.cpp:8:27: error: expected type-specifier before '.' token
         cantover& operator.() 
                           ^
prog.cpp:8:19: error: expected ';' at end of member declaration
         cantover& operator.() 
                   ^
prog.cpp:8:27: error: expected unqualified-id before '.' token
         cantover& operator.() 
                           ^
prog.cpp: In function 'void g(X&)':
prog.cpp:13:14: error: 'void X::fun()' is private
         void fun();
              ^
prog.cpp:18:15: error: within this context
         x.fun();              // X::fun or cantover::fun or error?
               ^

This problem can be solved in several ways. At the time of standardization, it was not obvious which way would be best.

This article is contributed by Shivani Ghughtyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Recommended Posts: