如何实现一个虚函数equal（）

Question

我想实现一个函数来比较派生类。但是我发现我必须将基类对象转换为派生类对象。

有没有办法避免使用强制转换或其他更好的设计来实现比较功能？

class A { 
    public : 
     virtual bool equal(const A & obj) const = 0; 
}; 

class AA : public A{ 
    public: 
     AA (int i) : m_i(i) {} 
     virtual bool equal(const A & obj) const 
     { 
      return m_i == dynamic_cast<const AA&>(obj).m_i; 
     } 

    private: 
     int m_i; 
}; 

int main() { 
    AA aa1(10), aa2(9); 
    A &a1 = aa1, &a2 = aa2; 

    a1.equal(a2); 

    return 0; 
} 

Answer 1

我在自己的代码中多次被这个请求咬了。我将介绍一个简单的例子：

struct Fruit 
{ 
    virtual bool is_equal(Fruit const & f) const = 0; // Compare two fruits 
    // Some dangerous actions: 
    bool operator==Fruit const & f) 
    { 
    return is_equal(f); // Dispatch! 
    } 
}; 

struct Strawberry : public Fruit 
{ 
    bool is_equal(Fruit const & f) 
    { 
    bool equal = false; 
    // The f could be any fruit, such as tomatoes or pineapples or bananas. 
    // Need to perform a dynamic_cast to verify that the f is a strawberry. 
    Strawberry const & s = dynamic_cast<Strawberry const &>(f); 
    // perform strawberry comparison; 
    return equal; 
    }; 
} 

struct Banana : public Fruit 
{ 
    bool is_equal(Fruit const & f) 
    { 
    bool equal = false; 
    // The f could be any fruit, such as tomatoes or pineapples or strawberries. 
    // Need to perform a dynamic_cast to verify that the f is a banana. 
    Banana const & b = dynamic_cast<Banana const &>(f); 
    // perform banana comparison; 
    return equal; 
    }; 
} 

bool Compare_Fruits(Fruit const * pf1, Fruit const * pf2) 
{ 
    if (*pf1 == *pf2) 
    { 
    cout << "Fruits are equal\n"; 
    return true; 
    } 
    cout << "Fruits are different\n"; 
    return false; 
} 

int main(void) 
{ 
    // Fun with fruit. 
    Fruit * p_fruit_1 = new Strawberry; 
    Fruit * p_fruit_2 = new Banana; 
    Fruit * p_fruit_3 = new Strawberry; 

    // Is this valid, comparing two different fruits, when 
    // we just want to compare two strawberries? 
    if (Compare_Fruits(p_fruit_1, p_fruit_3)) // OK, both are strawberries 
    { 
    // ... 
    } 
    if (Compare_Fruits(p_fruit_1, p_fruit_2)) // Not OK, two different fruits. 
    { 
    // ... 
    } 
    return 0; 
} 

这里的关键是，如果要实现在基类中的相同操作，使后代可以比较的情况下，你做了个错误的决定。请注意，我可以将指向一个后代（草莓）的实例的指针传递给另一个后代（香蕉）的比较方法，因为相等函数基于指向基类的指针。不幸的是，没有办法知道派生自基类的后代有多少或全部。

对于编程安全性，我强烈建议不要将虚拟比较运算符放在基类中。基类应该有比较运算符，声明为protected，只比较基础数据成员。这种方法将由后代调用。