Rápido y sucio operador!=

Question

En mis clases, me escriben a menudo una rápida operator!= por la devolución de los !(*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 veo ningún problema obvio con hacer esto, pero pensé que me gustaría preguntar si alguien sabe de alguna.

Answer 1

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

Answer 2

La definición de operator!= como !operator== está bien

Para conseguir estos trivial operadores equivalentes fácil de definir, yo siempre uso Boost.Los operadores.
El caso con sólo operator== y operator!= (es decir,el uso de equality_comparable<>) no aumenta mucho.

Pero cuando se necesita menos y mas que demasiado, o alguna combinación de operator+, operator* etc.esto resulta muy conveniente.

Un ejemplo para tu caso sería de leer

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_;
   }

};

Answer 3

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