Opérateur rapide et sale! =

Question

Dans mes cours, j’écris souvent un rapide operator!= en renvoyant !(*this == rhs), par exemple:

.

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

Je ne vois pas de problème évident à le faire, mais je pensais que je demanderais si quelqu'un en connaît un.

Answer 1

Je pense que c'est la méthode préférée pour implémenter operator!= afin que vous ne vous répétiez pas et que vous ayez une relation correcte garantie avec operator==.

Answer 2

Définir operator!= comme !operator== convient parfaitement

Pour que ces opérateurs équivalents triviaux soient facilement définis, j'utilise toujours Boost.Operators .
Le cas avec seulement operator== et operator+ (c'est-à-dire avec égalité_comparable < > ) ne gagne pas grand chose.

Mais lorsque vous avez besoin de moins et de plus que de trop, ou d'une combinaison de operator*, <=> etc., cela devient très pratique.

Un exemple pour votre cas se lirait

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

Non, c'est très bien, je fais exactement la même chose.