关于具有父子关系时的c ++运算符分配行为

Question

我有一个关于接受父引用类型的operator= 的问题。

当有一个抽象类并且它是实现类时， 为什么只有一个接受父引用类型的operator= 还不够？

下面是我的代码

#include <iostream>

class AbstractType {
    public:
        virtual ~AbstractType() {}
        virtual AbstractType& operator=(const AbstractType& other) {
            std::cout << "AbstractType& operator=(const AbstractType&)" << std::endl;
            return *this;
        }
};

class Type1: public AbstractType {
    public:
        virtual ~Type1() {}
        virtual Type1& operator=(const AbstractType& other) {
            std::cout << "Type1& operator=(const AbstractType&)" << 
std::endl;
            return *this;
        }

        /*
        virtual Type1& operator=(const Type1& other) {
            std::cout << "Type1& operator=(const Type1&)" << std::endl;
            // Just redirecting here! What a waste!
            return operator=(dynamic_cast<const AbstractType&>(other));
        }
        */
};

int main()
{
    Type1 t1;
    AbstractType& r1 = t1;

    Type1 t2;
    AbstractType& r2 = t2;


    // Type1& operator=(const AbstractType&). It's fine!
    r1 = r2;

    // AbstractType& operator=(const AbstractType&)!! Why??
    // Expected `Type1& operator=(const AbstractType&)` to be called!
    t1 = t2; 

    return 0;
}

您可以发现给定的参数只是在Type1& operator=(const Type1&) 中被重定向，而被注释忽略。

取消注释Type1& operator=(const Type1&) 只是为我工作， 但是如果说，我有一百多个 TypeX，那么我必须进行两百个复制分配，这是我无法理解的，因为在我看来，只有 Type1& operator=(const AbstractType& other) 就足够了。

在大多数情况下，我只有 AbstractType 来处理周围的事情。 在有限的情况下，很少能提前知道它的具体类型。

谁能建议我更好的解决方案？

Answer 1

// AbstractType& operator=(const AbstractType&)!! Why??
// Expected `Type1& operator=(const AbstractType&)` to be called!
t1 = t2; 

你在这里打电话：

t1.operator=(t2);

由于t1和t2有Type1，编译器会匹配以下函数：

Type1 & Type1::operator=(const Type1 &);

这是隐式定义的复制赋值运算符，它将调用基的复制赋值运算符：

AbstractType & AbstractType::operator=(const AbstractType &);

但是，此调用不是动态分派的——这就是您最终看到结果的原因。

---

取消注释 Type1& operator=(const Type1&) 只是为我工作

注意：

• 不需要dynamic_cast。
• 无需进行虚拟通话。
• 操作员本身不需要是virtual。

换句话说，您可以简化为：

Type1& operator=(const Type1& other)
{
    return Type1::operator=(static_cast<const AbstractType&>(other));
}

Answer 2

因为Liskovs substitution principle，它指出如果程序、模块或函数正在使用基类，则可以将基类的引用替换为派生类而不影响程序功能。因此，在您的特定情况下，根据Curiously recurring template pattern 实现它将是一个优雅的解决方案。请参阅link 了解更多信息！