c++ - 调用基类克隆实现

Question

尝试实现克隆模式，但坚持函数调用顺序:

我有一个 Base 类，其中包含一个多态类 vector (脚本)。

基 类实现了一个克隆函数，该函数本质上是复制其自身及其所有成员(mScripts vector )。

Derived 类也实现了它自己的克隆函数版本，并负责其成员的克隆。目前只是一个整数。

问题:我应该如何调用Base类的克隆函数，在Derived类的克隆函数中，让每个类负责克隆自己的成员？

作为一个丑陋的解决方法，现在，我所有派生类的克隆函数手动执行 mScripts vector 克隆，基本上重复相同的代码。

class Base
{
public:

    virtual std::unqique_ptr<Base> clone()
    {
        std::unique_ptr<Base> clonedInstance = std::make_unique<Base>();

        //clone the underlying vector
        for(int i = 0; i < mScripts.size(); ++i)
        {
            clonedInstance->mScripts.push_back(std::move(mScripts[i]->clone()));
        }

        return std::move(clonedInstance);
    }

    std::vector<std::unique_ptr<ScriptBase>>    mScripts;   //polymorphic array
};



class Derived : public Base
{
public:

    Derived(const int x) : Base(), mX(x)
    {
    }

    std::unqique_ptr<Base> clone()
    {
        //calling base::clone() here?

        return std::unique_ptr<Base> clonedInstance = std::make_unique<Derived>(mX);
    }

private:

    int mX;

};

Answer 1

正确实现复制构造函数，那么每个克隆函数就是return std::make_unique<Derived>(*this);

class Base
{
public:
    Base() = default;
    Base(const Base& rhs) // default is not fine here
    {
        for (const auto& script : rhs.mScripts)
        {
            mScripts.push_back(script->clone());
        }
    }
    virtual ~Base() = default;

    virtual std::unique_ptr<Base> clone() const
    {
        return std::make_unique<Base>(*this);
    }

    std::vector<std::unique_ptr<ScriptBase>> mScripts;   //polymorphic array
};

class Derived : public Base
{
public:
    Derived(int x) : Base(), mX(x) {}
    Derived(const Derived&) = default; // Default is fine here

    std::unique_ptr<Base> clone() const override
    {
        return std::make_unique<Derived>(*this);
    }

private:
    int mX;
};