Как правильно перегрузить operator == для иерархии классов?

Для такого рода иерархии я определенно следую совету Скотта Мейера по эффективному C ++ и избегаю использования каких-либо конкретных базовых классов. В любом случае, похоже, вы это делаете.

Я бы реализовал operator== как бесплатные функции, возможно друзья, только для конкретных типов классов листовых узлов.

Если базовый класс должен иметь элементы данных, я бы предоставил (возможно, защищенную) невиртуальную вспомогательную функцию в базовом классе (скажем, isEqual), которую могли бы использовать производные классы operator==.

E.g.

bool operator==(const B& lhs, const B& rhs)
{
    return lhs.isEqual( rhs ) && lhs.bar == rhs.bar;
}

Избегая использования operator==, который работает с абстрактными базовыми классами, и сохраняя защищенные функции сравнения, вы никогда не получите случайных откатов в клиентском коде, когда сравнивается только базовая часть двух разнотипных объектов.

Я не уверен, реализовал бы я функцию виртуального сравнения с dynamic_cast, я бы не стал это делать, но если бы в этом была доказанная необходимость, я бы, вероятно, выбрал чистую виртуальную функцию в базовом классе ( not operator==), который затем был переопределен в конкретных производных классах как что-то вроде этого, используя operator== для производного класса.

bool B::pubIsEqual( const A& rhs ) const
{
    const B* b = dynamic_cast< const B* >( &rhs );
    return b != NULL && *this == *b;
}

На днях у меня была такая же проблема, и я пришел к следующему решению:

struct A
{
    int foo;
    A(int prop) : foo(prop) {}
    virtual ~A() {}
    virtual bool operator==(const A& other) const
    {
        if (typeid(*this) != typeid(other))
            return false;

        return foo == other.foo;
    }
};

struct B : A
{
    int bar;
    B(int prop) : A(1), bar(prop) {}
    bool operator==(const A& other) const
    {
        if (!A::operator==(other))
            return false;

        return bar == static_cast<const B&>(other).bar;
    }
};

struct C : A
{
    int baz;
    C(int prop) : A(1), baz(prop) {}
    bool operator==(const A& other) const
    {
        if (!A::operator==(other))
            return false;

        return baz == static_cast<const C&>(other).baz;
    }
};

Что мне в этом не нравится, так это типичный чек. Что вы думаете об этом?

Если вы не хотите использовать приведение типов, а также убедитесь, что вы случайно не сравните экземпляр B с экземпляром C, тогда вам необходимо реструктурировать иерархию классов таким образом, как предлагает Скотт Мейерс в пункте 33 документа «Более эффективный C ++». Фактически этот элемент имеет дело с оператором присваивания, который действительно не имеет смысла, если используется для несвязанных типов. В случае операции сравнения имеет смысл вернуть false при сравнении экземпляра B с C.

Ниже приведен пример кода, который использует RTTI и не разделяет иерархию классов на конкретные листы и абстрактную основу.

В этом примере кода хорошо то, что вы не получите std :: bad_cast при сравнении несвязанных экземпляров (например, B с C). Тем не менее, компилятор позволит вам делать то, что вы могли бы пожелать, вы могли бы таким же образом реализовать оператор ‹и использовать его для сортировки вектора различных экземпляров A, B и C.

в прямом эфире

#include <iostream>
#include <string>
#include <typeinfo>
#include <vector>
#include <cassert>

class A {
    int val1;
public:
    A(int v) : val1(v) {}
protected:
    friend bool operator==(const A&, const A&);
    virtual bool isEqual(const A& obj) const { return obj.val1 == val1; }
};

bool operator==(const A& lhs, const A& rhs) {
    return typeid(lhs) == typeid(rhs) // Allow compare only instances of the same dynamic type
           && lhs.isEqual(rhs);       // If types are the same then do the comparision.
}

class B : public A {
    int val2;
public:
    B(int v) : A(v), val2(v) {}
    B(int v, int v2) : A(v2), val2(v) {}
protected:
    virtual bool isEqual(const A& obj) const override {
        auto v = dynamic_cast<const B&>(obj); // will never throw as isEqual is called only when
                                              // (typeid(lhs) == typeid(rhs)) is true.
        return A::isEqual(v) && v.val2 == val2;
    }
};

class C : public A {
    int val3;
public:
    C(int v) : A(v), val3(v) {}
protected:
    virtual bool isEqual(const A& obj) const override {
        auto v = dynamic_cast<const C&>(obj);
        return A::isEqual(v) && v.val3 == val3;
    }
};

int main()
{
    // Some examples for equality testing
    A* p1 = new B(10);
    A* p2 = new B(10);
    assert(*p1 == *p2);

    A* p3 = new B(10, 11);
    assert(!(*p1 == *p3));

    A* p4 = new B(11);
    assert(!(*p1 == *p4));

    A* p5 = new C(11);
    assert(!(*p4 == *p5));
}

Если вы сделаете разумное предположение, что типы обоих объектов должны быть идентичными, чтобы они были равными, есть способ уменьшить количество шаблонов, необходимых в каждом производном классе. Это следует за рекомендацией Херба Саттера по защите виртуальных методов и их скрытию за общедоступным интерфейсом. Любопытно повторяющийся шаблон шаблона (CRTP) используется для реализации стандартного кода в методе equals, поэтому производным классам не нужно.

class A
{
public:
    bool operator==(const A& a) const
    {
        return equals(a);
    }
protected:
    virtual bool equals(const A& a) const = 0;
};

template<class T>
class A_ : public A
{
protected:
    virtual bool equals(const A& a) const
    {
        const T* other = dynamic_cast<const T*>(&a);
        return other != nullptr && static_cast<const T&>(*this) == *other;
    }
private:
    bool operator==(const A_& a) const  // force derived classes to implement their own operator==
    {
        return false;
    }
};

class B : public A_<B>
{
public:
    B(int i) : id(i) {}
    bool operator==(const B& other) const
    {
        return id == other.id;
    }
private:
    int id;
};

class C : public A_<C>
{
public:
    C(int i) : identity(i) {}
    bool operator==(const C& other) const
    {
        return identity == other.identity;
    }
private:
    int identity;
};

См. Демонстрацию на http://ideone.com/SymduV

1. Я думаю, это выглядит странно:

   void foo(const MyClass& lhs, const MyClass& rhs) {
     if (lhs == rhs) {
       MyClass tmp = rhs;
       // is tmp == rhs true?
     }
   }
   

2. Если реализация operator == кажется правильным вопросом, подумайте о стирании типа (в любом случае подумайте об стирании типа, это прекрасный метод). Вот это описание Шона Родителя. Тогда вам все равно придется выполнить множественную отправку. Это неприятная проблема. Вот об этом.

3. Рассмотрите возможность использования вариантов вместо иерархии. Они легко могут делать такие вещи.