rapida e gestore sporco =

Question

Nelle mie classi ho spesso scrivere la rapida 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 evidenti problemi con il fare questo, ma ho pensato di chiedere se qualcuno sa di qualsiasi

Answer 1

Credo che sia il metodo preferito per implementare operator!= in modo da non ripetersi e si ha una relazione corretta garantita con operator==.

Answer 2

No, è assolutamente perfetto - Faccio esattamente la stessa cosa.

Answer 3

Definire operator!= come !operator== è bene

Per ottenere questi operatori equivalenti banali facilmente definiti, io uso sempre Boost.Operators.
Il caso con solo operator== e operator!= (vale a dire utilizzando equality_comparable<>) non guadagna molto.

Ma quando è necessario meno e maggiore di troppo, o una combinazione di operator+, operator* ecc. Diventa molto conveniente.

Un esempio per il vostro caso avrebbe letto

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

};