C++ 中派生类的相等性测试

Question

可能的重复：
重载运算符==的正确方法是什么类层次结构？

在 C++ 中，派生类如何以有意义的方式重写基类相等性测试？

例如，假设我有一个基类 A。类 B 和 C 派生自 A。现在给定两个指向两个 A 对象的指针，我可以测试它们是否相等（包括任何子类数据）吗？

class A {
    public: int data;
};

class B : public A {
    public: float more_data; bool something_else;
};

class C : public A {
    public: double more_data;
};


    A* one = new B;
    A* two = new B;
    A* three = new C;

    //How can I test if one, two, or three are equal
    //including any derived class data?

有干净的方法吗？我最好的选择是什么？

谢谢！

Answer 1

我记得读过对 public-non-virtual/non-public-virtual 习语及其优点的简洁描述，但不记得在哪里。 这本维基百科有一个不错的描述。

以下是将其应用到 op== 的方法：

struct A {
  virtual ~A() {}

  int a;

  friend
  bool operator==(A const& lhs, A const& rhs) {
    return lhs.equal_to(rhs);
  }
  // http://en.wikipedia.org/wiki/Barton-Nackman_trick
  // used in a simplified form here

protected:
  virtual bool equal_to(A const& other) const {
    return a == other.a;
  }
};

struct B : A {
  int b;

protected:
  virtual bool equal_to(A const& other) const {
    if (B const* p = dynamic_cast<B const*>(&other)) {
      return A::equal_to(other) && b == p->b;
    }
    else {
      return false;
    }
  }
};

struct C : A {
  int c;

protected:
  virtual bool equal_to(A const& other) const {
    if (C const* p = dynamic_cast<C const*>(&other)) {
      return A::equal_to(other) && c == p->c;
    }
    else {
      return false;
    }
  }
};

Answer 2

不同的派生类可以创建相同的对象吗？

如果是这样： 双重调度 是一个选项：它确实需要在基类中重载，所以你将会有依赖关系

如果没有：解决方案是在operator==()中检查typeid，如果它们不同则返回false。否则，调用私有 equal() 函数，其中派生类可以执行 static_cast 并进行比较。

bool base::operator==(const base& other) const
{
  if (typeid(*this) != typeid(other)) return false;
  return equal(other);
}

bool derived::equal(const base& other) const
{
  derived& derOther = static_cast<derived&>(other);
  // compare derOther with *this
  return true;  // there is nothing to compare
}

这避免了所有派生类中的类型检查

Answer 3

实现此目的的一种方法是使用虚拟运算符==，它将基类对象作为参数，以便它可以与不同的派生对象一起正常工作。但是，您需要使该函数成为纯虚函数，以便强制所有派生对象实现它。所以你将无法实例化基类。例如：

class A
{
public:
    virtual ~A(){}

    //A virtual operator for comparison
    virtual bool operator==(const A& a) = 0;

protected:
    bool compareBase(const A& a);

private:
    int m_data;
};

bool A::compareBase(const A &a)
{
    return m_data == a.m_data;
}

class B1 : public A
{
public:

    //Override the base class
    bool operator==(const A& a);

private:
    bool compare(const B1* pB)
    {
        if(compareBase(*pB))
        {
            //Code for compare
            return true;
        }

        return false;
    }
};

bool B1::operator ==(const A &a)
{
    //Make sure that the passed type is same
    const B1* pB = dynamic_cast<const B1*>(&a);
    if(pB )
    {
        return compare(pB);
    }

    return false;
}
//Similarly implement for B2

Answer 4

如果您不关心类型 A 与类型 B 或 B 与 C 等的比较，那么您可以简单地为每个类实现一个重载的相等运算符：

class A {
    public: int data;

    bool operator==(const A& rhs) {
        return (data == rhs.data);
    }
};
class B : public A {
    public: float more_data; bool something_else;

    bool operator==(const B& rhs) {
        return (A::operator==( data ) &&
                more_data == rhs.more_data &&
                something_else == rhs.something_else);
    }
};

但这很危险，因为如果您从 B 派生一个新类 D 或C，你将会遇到问题。

否则，您需要使用大量的dynamic_cast<>-ing来实现一些比较器才能真正做到正确。或者，您可以实现一个函数来为每个对象创建哈希码并利用它，例如，

class A {
    public: int data;

    virtual long getHashCode() const {
        // compute something here for object type A
    }

    // virtual here just in case you need to overload it in B or C
    virtual bool equals( const A& obj ) const {
        return (typeid(*this) == typeid(obj) &&
                getHashCode() == obj->getHashCode());
    }
};

class B : public A {
    public: float more_data; bool something_else;

    virtual long getHashCode() const {
        // compute something here for object type B
    }
};

class C : public A {
    public: double more_data;

    virtual long getHashCode() const {
        // compute something here for object type C
    }
};

如果您以某种方式将对象的类型合并到哈希码中（上面未显示），那么您也可以省去上面愚蠢的 typeid() 比较。

Answer 5

如果您不介意基类引用子类，那么可以双重调度：

#include <iostream>

class B;
class C;

class A
{
public:
    int data;

    virtual bool equals (const A* rhs) const
    {
        std::cout << " A==A ";
        return data == rhs->data;
    }

    virtual bool equals (const B* rhs) const {return false;}
    virtual bool equals (const C* rhs) const {return false;}
};

class B : public A
{
public:
    float some_data;

    virtual bool equals (const A* rhs) const
    {
        return rhs->equals (this);
    }

    virtual bool equals (const B* rhs) const
    {
        std::cout << " B==B ";
        return A::equals (static_cast<const A*> (rhs)) && some_data == rhs->some_data;
    }
};

class C : public A
{
public:
    double more_data;

    virtual bool equals (const A* rhs) const
    {
        return rhs->equals (this);
    }

    virtual bool equals (const C* rhs) const
    {
        std::cout << " C==C ";
        return A::equals (static_cast<const A*> (rhs)) && more_data == rhs->more_data;
    }
};

bool operator== (const A& lhs, const A& rhs)
{
    return lhs.equals (&rhs);
}

int main (int argc, char* argv[])
{

    A* one = new B;
    A* two = new B;
    A* three = new C;

    std::cout << (*one == *one) << std::endl;
    std::cout << (*one == *two) << std::endl;
    std::cout << (*one == *three) << std::endl;
    std::cout << (*three == *three) << std::endl;

    return 0;
}

不需要dynamic_casts。