¿Cuáles son los operadores que pueden y no pueden sobrecargarse en C++?

Hay varias formas de sobrecargar los operadores en C++ mediante la implementación de cualquiera de los siguientes tipos de funciones:

1) Función miembro

2) Función de no miembro

3) Función de amigo

La lista de operadores que se pueden sobrecargar son: 

Ejemplo 1: Sobrecarga del operador ++ 

// 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

Esta función se llama cuando el operador ++ opera sobre el objeto de la clase de sobrecarga (objeto i en este caso). En el programa, se define la función de operador void operator ++() (dentro de la clase de sobrecarga). Esta función incrementa el valor de cuenta en 1 para el objeto i.
Ejemplo 2: Sobrecarga del operador ++, es decir, operador de incremento previo y posterior 

// 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

Ejemplo 3: Sobrecarga del operador [ ] 

// 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

Ejemplo 4: Sobrecarga -> operador 

// 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

Lista de operadores que no se pueden sobrecargar

1) Operador de resolución de alcance  (::)    

2) Operador Ternario o Condicional (?:)   

3) Acceso de miembro o operador de punto (.)    

4) Operador de puntero a miembro (.*)  

5) Operador de tamaño de objeto ( tamaño de ) 

6) Operador de tipo de objeto (typeid) 

7) static_cast (operador de fundición)

8) const_cast (operador de fundición)

9) reinterpret_cast (operador de conversión)

10) dynamic_cast (operador de fundición)

Ejemplo 5: sobrecargar este operador .(punto) El
operador punto (.) no se puede sobrecargar, por lo que generará un 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?
}

Salida: Error

prog.cpp:12:23: error: expected type-specifier before ‘.’ token
    cantover& operator.() { return *p; }

Este programa generará un error. De manera similar, los operadores anteriores también generarán un error, si están sobrecargados.

Este artículo es una contribución de Shivani Ghughtyal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.