c++ - 使用基类和派生类移动赋值

Question

下面是我遇到问题的两个类的简化实现。

代码:

这是基类:

//header
class Script
{
public: 
    Script(const QString& path, int timeout=10000) : 
    mPath(path), mTimeout(timeout), script(new QProcess) {}
    Script(Script&& s);
    Script& operator=(Script&& s);
    virtual ~Script();

protected:
    QString mPath;
    int mTimeout;
    QProcess* script;
}

//source
Script::Script(Script&& s) :
    mPath(s.mPath), mTimeout(s.Timeout), script(s.script)
{
    s.script = nullptr;
}

Script& Script::operator=(Script&& s){
    if(&s != this){
        delete script;
        script = s.script;
        s.script = nullptr;

        mPath = s.mPath;
        mTimeout = s.mTimeout;
    }
    return *this;
}

Script::~Script() {
    delete script;
    script = nullptr;
}

从上面的代码片段中，我派生了以下类:

//header
class ConfigurationScript : public Script
{
public:
    ConfigurationScript(const QString& path);
    ConfigurationScript(ConfigurationScript&& s);
    ConfigurationScript& operator=(ConfigurationScript&& s);
}

//source
ConfigurationScript::ConfigurationScript(const QString& path) :
Script(path) {}

ConfigurationScript::ConfigurationScript(ConfigurationScript&& s) : 
Script(std::move(s)) {}

ConfiguratonScript& ConfigurationScript::operator=(ConfigurationScript&& s) {
    if(&s != this){
        delete script;
        script = s.script;
        s.script = nullptr;

        mPath = s.mPath;
        mTimeout = s.mTimeout;
    }
    return *this;
}

问题:

当您将 ConfigurationScript 的移动分配与其基类 Script 的移动分配进行比较时，它包含重复代码。能否调用基类的赋值运算符来克服重复代码？

例如这样的东西有效吗？

ConfigurationScript& ConfigurationScript::operator=(ConfigurationScript&& s) {
    if(&s != this){
        Script::operator=(s);
    }
    return *this;
}

Script::operator=(s) 的返回类型是Script，是否需要将其转换为ConfigurationScript？如果以上内容有效，我看不出它是如何工作的。否则，有没有办法避免代码重复？

Answer 1

是的，它是有效的，你不需要投任何东西。

您甚至没有使用基本 op= 调用的结果，但您知道它是一个引用当前对象的 Script&。由于您已经有一个引用当前对象的 ConfigurationScript& 并且 具有所需的类型(即 *this)，因此无需再做任何事情.

事实上，这很自然，您可以让编译器为您完成:

#include <iostream>
#include <utility>

struct Base
{
    Base& operator=(Base&& other)
    {
        std::cout << "YOLO!\n";
        return *this;
    }
};

struct Derived : Base
{
    /*
    // Don't need this
    Derived& operator=(Derived&& other)
    {
        Base::operator=(std::move(other));
        return *this;
    }*/

    /*
    // Or even this (though you may need to introduce it
    // if you have some other user-declared stuff)
    Derived& operator=(Derived&& other) = default;
    */
};

int main()
{
    Derived d1, d2;
    d2 = std::move(d1);
}

// Output: YOLO!

( live demo )

不过，我认为您的意思可能是 Script::operator=(std::move(s)) 获得真正的移动而不是复制。