Operatore veloce e sporco! =

Question

Nelle mie lezioni scrivo spesso operator!= restituendo !(*this == rhs), ad esempio:

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

Non riesco a vedere alcun ovvio problema nel farlo, ma ho pensato di chiedere se qualcuno ne fosse a conoscenza.

Answer 1

Credo che sia il metodo preferito di implementazione operator!= in modo da non ripetere te stesso e avere una relazione corretta garantita con operator==.

Answer 2

Definire operator!= come !operator== va bene

Per definire facilmente questi banali operatori equivalenti, uso sempre Boost.Operators .
Il caso con solo operator== e operator+ (ovvero utilizzando equality_comparable < > ) non guadagna molto.

Ma quando hai bisogno di sempre meno e anche di una combinazione di operator*, <=> ecc. questo diventa molto conveniente.

Un esempio per il tuo caso sarebbe leggere

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, va assolutamente bene, faccio esattamente lo stesso.