C++ 实现具有多级继承的对象相等性

Question

我需要为具有多个继承级别的多个对象实现一个 isEqual 方法。出于这个原因，我决定不创建接口，因为该方法不是纯虚拟的，而只是我以后可以用作标记的类。

这些类实现了一个方法 isEqual。由于我需要定义默认行为，因此这些方法不是纯虚拟的。

class A_Interface {
    virtual isEqual(shared_ptr<A_Interface> obj);
    ...
    virtual otherMethod1();
}


class B_Interface : public virtual A_Interface {
    virtual isEqual(shared_ptr<B_Interface> obj);
    ...
    virtual otherMethod2();
}


class C_Interface : public virtual B_Interface {
    virtual isEqual(shared_ptr<C_Interface> obj);
    ...
    virtual otherMethod3();
}

每个类都实现了它自己的上面提到的“类接口”标签类，并像这样从父类继承：

class A : public virtual A_interface;
{
    isEqual(shared_ptr<A_Interface> obj){
    ...
    }
};



class B : public virtual A, 
          public virtual B_interface 
                {
    using A::isEqual;
    isEqual(shared_ptr<B_Interface> obj){
    ...
    }
};


class C : public virtual B,
          public virtual C_interface 
  {
    using B::isEqual;
    isEqual(shared_ptr<C_Interface> obj){
    ...

    bool parentIsEquals = B::isEqual(obj);

    ...
    }
};

为了避免 B 类中的名称隐藏，我明确声明了

using A::isEqual;

解决了问题的语句，但现在在类 C 中，当我想引用方法“isEqual”父类 B 并像这样明确指定它时

bool parentIsEquals = B::isEqual(obj);

我得到了错误

"B::isEqual' is ambiguous"

我也明白，因为我有两个签名，即

using A::isEqual;
isEqual(shared_ptr<B_Interface> obj);

我不知道如何解决这个问题，因为这种情况下的参数“obj”确实与购买的签名匹配。 我想了解是否有更好的模式/建议来实现这个问题。

Answer 1

保持简单。

具有以下类层次结构：

struct A     { int value1; };
struct B : A { int value2; };
struct C : B { int value3; };

您可以为As、Bs 和Cs 定义相等运算符

bool operator==(A const& lhs, A const& rhs)
{
    return lhs.value1 == rhs->value1;
}
bool operator==(B const& lhs, B const& rhs)
{
    return lhs.value2 == rhs->value2
           && static_cast<A const&>(lhs) == static_cast<A const&>(rhs);
}
bool operator==(C const& lhs, C const& rhs)
{
    return lhs.value3 == rhs->value3
           && static_cast<B const&>(lhs) == static_cast<B const&>(rhs);
}

有了它，加了点糖：

template<class Wrapper>
bool operator==(A const& lhs, Wrapper const& rhs)
{ return lhs == *rhs; }
template<class Wrapper>
bool operator==(Wrapper const& rhs, A const& lhs)
{ return rhs == lhs; }
// and so on...

所有这些简单的功能都为您提供了极大的灵活性：

B b1{{1}, 2};
auto c2 = std::make_unique<C>(C{{{1}, 2}, 3});
bool const equals = b1 == c2; // true