rápida y sucia operador =

Question

En mis clases A menudo escribo una rápida operator!= devolviendo !(*this == rhs), por ejemplo:

class Foo 
{ 
private: 
    int n_; 
    std::string str_; 
public: 
    ... 
    bool operator==(const Foo& rhs) const 
    { 
     return n_ == rhs.n_ && str_ == rhs.str_; 
    } 

    bool operator!=(const Foo& rhs) const 
    { 
     return !(*this == rhs); 
    } 
}; 

no puedo ver ningún problema obvio con hacer esto, pero pensé en preguntar si alguien sabe de cualquier.

Answer 1

Creo que es el método preferido para implementar operator!= para que no se repita y tiene una relación correcta garantizada con operator==.

Answer 2

No, eso está absolutamente bien, hago exactamente lo mismo.

Answer 3

Definición operator!= como !operator== es bien

Para conseguir estos operadores equivalentes triviales definir fácilmente, siempre uso Boost.Operators.
La caja con solo operator== y operator!= (es decir, usando equality_comparable<>) no gana mucho.

Pero cuando necesita menos y más que también, o alguna combinación de operator+, operator* etc. esto se convierte en muy conveniente.

Un ejemplo para su caso leería

class Foo : private boost::equality_comparable<Foo> 
{ 
    private: 
    int n_; 
    std::string str_; 
    public: 
    ... 
    bool operator==(const Foo& rhs) const 
    { 
     return n_ == rhs.n_ && str_ == rhs.str_; 
    } 

};