Defining base class `operator==` in terms of derived class `operator==` in C++11?

Question

Suppose I have a type hierarchy:

struct B { ... };

struct D1 : B { ... };
struct D2 : B { ... };
...
struct Dn : B { ... };

Each Di has its own operator== defined:

struct Di : B
{
    bool operator==(const Di&) const { ... }
    ...
};

I now want to define the B operator== such that:

struct B
{
    bool operator==(const B& that) const
    {
        // psuedo-code
        let i, such the dynamic type of this is Di
        let j, such the dynamic type of that is Dj

        if (i != j)
            return false;
        else
            return Di::operator==(this, that);
    }
 }

What is the best way to organize this or write this?

(The end goal is that I want to use the standard container types with a value type of B* (eg std::set<B*>), but for it to use the custom Di::operator==s when they are from the same derived class)

Answer 1

Define a protected virtual function in the base class. Make it pure virtual to ensure that each subclass Di provides an implementation. The function will know the target of the cast, because it belongs to a Di. Call that function from the operator == in the base class, and let it perform the comparison, like this:

struct B {
    bool operator==(const B& that) const {
        return this->equals(that);
    }
protected:
    virtual bool equals(const B& other) const=0;
};
struct D1 {
protected:
    virtual bool equals(const B& other) const {
        D1 *that = dynamic_cast<D1*>(&other);
        if (!that) return false;
        // Perform D1-specific comparison here.
        // You can use the == operator of D1, but you do not have to:
        return (*this) == (*that);
    }
};

The effect of this construct is making the implementation of the == operator virtual.