C++ operador == sobrecarga

Question

Duplicar posible:
Operator overloading

¿Cuál es la diferencia entre las siguientes formas de sobrecargar el operador ==?

// stroustrup way 
friend bool operator== (MyClass &lhs, MyClass &rhs); 

y

// as taught in other places, including caltech 
bool MyClass::operator== (MyClass &rhs); 

¿Qué camino es mejor?

Answer 1

Este:

friend bool operator== (MyClass &lhs, MyClass &rhs); 

es una función, que compara dos objetos.

Este:

bool MyClass::operator== (MyClass &rhs); 

es una función miembro.

Debe usar la que propone su estándar de codificación o usar la que prefiera. Ninguno es mejor Algunas personas (incluyéndome a mí) prefieren tener el operador de comparación como una función, otros lo prefieren como una función de miembro. Por el contrario, los parámetros deben ser del tipo const MyClass &.

Answer 2

En primer lugar es amigo función externa (función gratuita)

friend bool operator== (MyClass &lhs, MyClass &rhs); 

En segundo lugar es función miembro

bool MyClass::operator== (MyClass &rhs); 

Debe utilizar segunda variante siempre, entonces puede

Debe usar primera variante de caso: 1) primer argumento es la clase externa (biblioteca)

friend ostream& operator<< (ostream &out, MyClass &m) 

2) la lógica del operador no relacionado con su clase y debe aplicarse por separado

friend bool operator(const MyClass& my, const std::string& string_form) 

(debido a que su clase no puede saber todo acerca de las clases que pueden necesitar en comparar operador)

Answer 3

// stroustrup way 
friend bool operator== (MyClass &lhs, MyClass &rhs); 

Los argumentos deben ser const - friend bool operator==(const MyClass& lhs, const MyClass& rhs);. Esto se prefiere ya que funciona cuando el primer argumento se puede construir implícitamente. Por ejemplo, si std::string solo tenía una función de miembro operator==, ¡"abc" == my_std_string no la invocaría! Pero, la función no miembro puede invocarse construyendo implícitamente una cadena desde "abc" (mejor aún en este caso particular, se puede proporcionar un bool operator==(const char*, const std::string&) por razones de rendimiento, pero el punto sigue en pie: las funciones no miembro pueden ayudar a garantizar el operador trabaja con el tipo definido por el usuario en cualquier lado).

Por separado, los constructores implícitos son un poco peligrosos, y usted quiere pensar mucho acerca de la conveniencia frente al peligro de usarlos.