动态转换还是函数重载？

Question

考虑以下抽象类：

class Abstract {
public:
    // ...

    virtual bool operator==(const Abstract& rhs) const = 0;

    // ...
};

现在假设我从这个抽象类创建多个派生类。但是，每个类在与自己的类型进行比较时都使用不同的算法，在与任何其他派生类进行比较时使用通用算法。在以下两个选项中，哪个是更好、更有效的选项？

选项 A：

class Derived : public Abstract {
public:
    // ...

    bool operator==(const Abstract& rhs) const {
        // Code for comparing to any of the other derived classes
    }

    bool operator==(const Derived& rhs) const {
        // Code for comparing to myself
    }

    // ...
};

选项 B：

class Derived : public Abstract {
public:
    // ...

    bool operator==(const Abstract& rhs) const {
        const Derived* tmp = dynamic_cast<const Derived*>(&rhs);
        if (tmp) {
            // Code for comparing to myself
        }
        else {
            // Code for comparing to any of the other derived class
        }
    }
};

我真的很好奇这些选项有什么优点和缺点，因为 C++ 类型转换对我来说是一个相对神秘的话题。此外，哪种解决方案更“标准”，第二种解决方案对性能有任何影响吗？

是否有可能有第三种解决方案？特别是如果有许多派生类，每个派生类都需要针对不同派生类有自己的特殊比较算法？

Answer 1

您的两种方法适用于不同的情况。对于选项 A，rhs 的静态类型用于决定调用哪个函数，而对于选项 B，则使用动态类型。

因此，如果您希望程序根据参数的“真实”类型选择其行为，我认为您应该选择第二个选项。如果可以在编译时知道类型，则应使用选项 A，因为它提供更好的性能。

Answer 2

我认为如果您希望 == 运算符使用参数的动态类型，那么选项 B 就是您所寻找的。例如：

class base
{
public:
  virtual bool operator ==( const base& other ) = 0;
};

class derived : public base
{
public:
  bool operator ==( const base& other ) { return false; }
  bool operator ==( const derived& other ) { return true; }
};


int main()
{
  base* a = new derived;
  base* b = new derived;
  std::cout << ( *a == *b ) << std::endl;
}

这会打印：

0

所以运算符 ==( const base& other ) 会被调用，即使实际的动态类型是派生的。

Answer 3

实际上，您可以使用其中一种技术来实现第三种方式来实现双重调度。 “更有效的 C++”的第 31 条对此方法进行了完整描述。这是一个小例子：

#include <iostream>

class Derived1;
class Derived2;

class Base
{
public:
    virtual bool operator==( Base& other) = 0;
    virtual bool compare( Base& other) {return false;}
    virtual bool compare( Derived1& other) {return false;}
    virtual bool compare( Derived2& other) {return false;}
};

class Derived1 : public Base
{
public:
    virtual bool operator==( Base& other) {return other.compare(*this);}

    virtual bool compare( Base& other) {return false;}
    virtual bool compare( Derived1& other) {return true;}
};

class Derived2 : public Base
{
public:
    virtual bool operator==( Base& other) {return other.compare(*this);}

    virtual bool compare( Base& other) {return false;}
    virtual bool compare( Derived2& other) {return true;}
};

int main()
{
    Base *a = new Derived1;
    Base *b = new Derived1;
    Base *c = new Derived2;

    std::cout << (*a == *b) << std::endl;
    std::cout << (*a == *c) << std::endl;
    return 0;
}

输出：

1
0

Answer 4

不幸的是，C++ 没有多种方法可以根据动态类型信息选择要调用的当前函数。您需要双重调度、访问者模式或其他一些技巧来实现该行为。