C++ múltiples sobrecargas de operador para el mismo operador

Question

Sé que puedo responder esta pregunta fácilmente generando el código y ver si se compila. Pero como no pude encontrar una pregunta similar, pensé que valía la pena compartirla. Supongamos que estoy sobrecargando el operador + de MyClass. ¿Puedo sobrecargarlo varias veces? Diferente sobrecarga para diferentes tipos. De esta manera:

class MyClass{ 
... 
inline const MyClass operator+(const MyClass &addend) const { 
    cout<<"Adding MyClass+MyClass"<<endl; 
    ...//Code for adding MyClass with MyClass 
} 
inline const MyClass operator+(const int &addend) const { 
    cout<<"Adding MyClass+int"<<endl; 
    ...//Code for adding MyClass with int 
} 
... 
}; 
int main(){ 
    MyClass c1; 
    MyClass c2; 
    MyClass c3 = c1 + c2; 
    MyClass c4 = c1 + 5; 
} 
/*Output should be: 
    Adding MyClass+MyClass 
    Adding MyClass+in*/ 

La razón por la que quiero hacer esto es que estoy construyendo una clase que yo quiero estar tan optimizado como sea posible. El desempeño es la mayor preocupación para mí aquí. Así que fundir y usar la caja del interruptor dentro del operador + función sobrecargada no es una opción. Si lo nota, hice las dos sobrecargas en línea. Supongamos por un segundo que el compilador en verdad indica mis sobrecargas, luego está predeterminado en tiempo de compilación qué código se ejecutará, y guardo la llamada a una función (al subrayar) + un escenario complicado de caso de conmutación (en realidad, habrá Más de 5 sobrecargas para el operador +), pero todavía puedo escribir código de lectura fácil usando operadores aritméticos básicos. Entonces, ¿obtendré el comportamiento deseado?

Answer 1

La forma canónica de implementar operator+() es una función gratuita basada en operator+=(), que los usuarios esperarán cuando tenga +. += cambia su argumento de la izquierda y, por lo tanto, debe ser un miembro. El + trata sus argumentos de forma simétrica y, por lo tanto, debe ser una función libre.

Algo como esto debería hacer:

//Beware, brain-compiled code ahead! 
class MyClass { 
public: 
    MyClass& operator+=(const MyClass &rhs) const 
    { 
     // code for adding MyClass to MyClass 
     return *this; 
    } 
    MyClass& operator+=(int rhs) const 
    { 
     // code for adding int to MyClass 
     return *this; 
    } 
}; 


inline MyClass operator+(MyClass lhs, const MyClass& rhs) { 
    lhs += rhs; 
    return lhs; 
} 
inline MyClass operator+(MyClass lhs, int rhs) { 
    lhs += rhs; 
    return lhs; 
} 
// maybe you need this one, too 
inline MyClass operator+(int lhs, const MyClass& rhs) { 
    return rhs + lhs; // addition should be commutative 
} 

(Tenga en cuenta que las funciones miembro definidas con su definición de clase son implícitamente inline Tenga en cuenta también, que dentro de MyClass, el prefijo MyClass:: o bien no es necesario o incluso mal..)

Answer 2

Sí.

---

Estas funciones de operador son sólo funciones normales con los nombres especiales operator@. No hay restricción de que no puedan ser sobrecargados. De hecho, el operador << utilizado por iostream es un operador con múltiples sobrecargas.

Answer 3

Sí, puede sobrecargar a los operadores de esta manera. Pero no estoy seguro de a qué "caja del interruptor" te refieres. Puede vivir con una sobrecarga si tiene un constructor de conversión

class MyClass{ 
... 
// code for creating a MyClass out of an int 
MyClass(int n) { ... } 
... 
inline const MyClass MyClass::operator+(const MyClass &addend) const { 
    cout<<"Adding MyClass+MyClass"<<endl; 
    ...//Code for adding MyClass with MyClass 
} 
... 
}; 

No se necesita ningún interruptor. Esto es elegible si "MyClass" representa lógicamente un número.

Observe que debe sobrecargar estos operadores por funciones que no son miembros. En su código 5 + c1 no funcionaría, porque no hay ningún operador que tome un int como lado izquierdo. El siguiente funcionaría

inline const MyClass operator+(const MyClass &lhs, const MyClass &rhs) { 
    // ... 
} 

Ahora bien, si se mantiene el constructor de conversión puede agregar el int por cada lado con una sobrecarga código mínimo.