!= 运算符应该在类层次结构中定义在哪里？

Question

这是一个非常简单的类层次结构：

class A
{
public:
    A( int _a ) : a( _a ) {}

    virtual bool operator==( const A& right ) const
    {
        return a == right.a;
    }

    virtual bool operator!=( const A& right ) const
    {
        return !( *this == right );
    }

    int a;
};

class B : public A
{
public:
    B( int _a, int _b ) : A( _a ), b( _b ) {}

    virtual bool operator==( const B& right ) const
    {
        return A::operator==( right ) && b == right.b;
    }

    int b;
};

如您所见，运算符 != 是在基类中定义的。因为我很懒，不想在所有的派生类里都复制这么简单的代码。

不幸的是，使用此代码：

A a4(4), a5(5), a4bis(4);
assert( a4 == a4bis );
assert( a4 != a5 );

B b1(4,5), b2(4,6);
assert( !(b1 == b2) );
assert( b1 != b2 ); // fails because B::operator== is not called!

b1 != b2返回false，因为它执行A::operator!=，然后调用A::operator==而不是B::operator==（即使操作符是虚拟的，因为派生类版本参数不同，它们在vtable中没有链接） .

那么，对于类层次结构，以通用方式处理 != 运算符的最佳方式是什么？

一种解决方案是在每个班级重复它，B 将有：

virtual bool operator!=( const B& right ) const
{
    return !( *this == right );
}

但是当你有很多课程时，这很痛苦......我有 30 个......

另一种解决方案是使用通用模板方法：

template <class T>
bool operator!=( const T& left, const T& right )
{
    return !( left == right );
}

但这绕过了任何类定义的任何!= 运算符....因此，如果以不同方式声明它可能会有风险（或者如果一个声明== 本身调用!=，它最终会得到一个无限循环...）。所以我觉得这个解决方案非常不安全......除非我们可以限制模板用于从我们层次结构的顶级类派生的所有类（在我的示例中为A）......但我不'认为这根本不可行。

注意：我还没有使用 C++11……很抱歉。

Answer 1

你在B中的函数...

virtual bool operator==( const B& right ) const

...不覆盖A...中的函数...

virtual bool operator==( const A& right ) const

...因为参数类型不同。 （只有协变返回类型允许差异。）

如果您更正此问题，您将能够选择如何将 B 对象与其他 A 和 A 派生对象进行比较，例如也许：

bool operator==( const A& right ) const override
{
    if (A::operator==( right ))
        if (typeid(*this) == typeid(right))
            return b == static_cast<const B&>(right).b;
    return false;
}

请注意，使用上面的typeid 比较意味着只有B 对象将比较相等：任何B 将与任何B 派生对象比较不相等。这可能是也可能不是您想要的。

使用B::operator== 的实现，现有的!= 实现将正确包装operator==。正如 Jarod42 所观察到的，您的 A::operator== 并不稳健，因为当左侧值为 A 时，只会比较右侧对象的 A 切片......您可能更喜欢：

virtual bool operator==(const A& right) const
{
    return a == right.a && typeid(*this) == typeid(right);
}

这与上面的B::operator== 有相同的问题：例如A 将与未引入更多数据成员的派生对象进行比较。

Answer 2

这样的事情怎么样？

class A {
  protected :
    virtual bool equals(const A& right) const {
      return (a == right.a);
    }

  public :
    A(int _a) : a(_a) { }

    bool operator==(const A& right) const {
      return this->equals(right);
    }
    bool operator!=(const A& right) const {
      return !(this->equals(right));
    }

    int a;
};

class B : public A {
  protected :
    virtual bool equals(const A& right) const {
      if (const B* bp = dynamic_cast<const B*>(&right)) {
        return A::equals(right) && (b == bp->b);
      }
      return false;
    }

  public :
    B(int _a, int _b) : A(_a), b(_b) { }

    int b;
};

将比较逻辑移至单独的（虚拟）函数equals，并从基类中定义的operator== 和operator!= 调用该函数。

操作符不需要在派生类中重新定义。要更改派生类中的比较，只需覆盖 equals。

请注意，上面代码中的dynamic_cast 用于确保运行时类型是执行比较的有效类型。 IE。对于B::equals，它用于确保right 是B - 这是必要的，因为否则right 将没有b 成员。