Operador rápido e sujo! =

Question

Nas minhas aulas, muitas vezes escrevo um rápido operator!= retornando !(*this == rhs), por exemplo:

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

Não vejo problemas óbvios em fazer isso, mas pensei em perguntar se alguém conhece algum.

Answer 1

Eu acredito que esse é o método preferido de implementar operator!= para que você não se repita e tenha um relacionamento correto garantido com operator==.

Answer 2

Definindo operator!= Como !operator== está bem

Para obter esses operadores equivalentes triviais facilmente definidos, eu sempre uso Boost.operadores.
O caso apenas com operator== e operator!= (ou seja, usando Equality_comparable <>) não ganha muito.

Mas quando você precisa de cada vez maior do que também, ou alguma combinação de operator+, operator* etc. Isso se torna muito conveniente.

Um exemplo para o seu caso leria

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

Não, tudo bem - eu faço exatamente o mesmo.