C++ 调用基类克隆实现

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

我有一个带有多态类向量（脚本）的Base类

Base类实现了一个克隆函数，它本质上是用它的所有成员（mScripts向量）复制它自己

派生的类还实现了自己版本的克隆函数，并负责其成员的克隆。此时它只是一个整数

问题：在派生的类的克隆函数中，我应该如何调用基类的克隆函数，这样每个类都会负责自己成员的克隆

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

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;

};

类基
{
公众：
虚拟std:：unqique_ptr clone（）
{
std:：unique_ptr clonedInstance=std:：make_unique（）；
//克隆底层向量
对于（int i=0；imScripts.push_back（std:：move（mScripts[i]->clone（））；
}
返回std:：move（clonedInstance）；
}
std:：vector mScripts；//多态数组
};
派生类：公共基
{
公众：
派生（常量int x）：Base（），mX（x）
{
}
std:：unqique_ptr clone（）
{
//在这里调用base:：clone（）？
返回std:：unique_ptr clonedInstance=std:：make_unique（mX）；
}
私人：
int-mX；
};

正确地实现复制构造函数，然后每个克隆函数只返回std:：make_unique（*this）

类基
{
公众：
Base（）=默认值；
Base（const Base&rhs）//这里的默认值不好
{
用于（常量自动和脚本：rhs.mScripts）
{
mScripts.push_back（脚本->克隆（））；
}
}
virtual~Base（）=默认值；
虚拟std:：unique_ptr clone（）常量
{
return std:：make_unique（*this）；
}
std:：vector mScripts；//多态数组
};
派生类：公共基
{
公众：
派生的（intx）：Base（），mX（x）{}
派生的（const-Derived&）=default；//这里可以使用默认值
std:：unique_ptr clone（）常量覆盖
{
return std:：make_unique（*this）；
}
私人：
int-mX；
};

正确地实现复制构造函数，然后每个克隆函数只返回std:：make_unique（*this）

类基
{
公众：
Base（）=默认值；
Base（const Base&rhs）//这里的默认值不好
{
用于（常量自动和脚本：rhs.mScripts）
{
mScripts.push_back（脚本->克隆（））；
}
}
virtual~Base（）=默认值；
虚拟std:：unique_ptr clone（）常量
{
return std:：make_unique（*this）；
}
std:：vector mScripts；//多态数组
};
派生类：公共基
{
公众：
派生的（intx）：Base（），mX（x）{}
派生的（const-Derived&）=default；//这里可以使用默认值
std:：unique_ptr clone（）常量覆盖
{
return std:：make_unique（*this）；
}
私人：
int-mX；
};

例如，定义一个额外的构造函数，该构造函数接受

基

作为参数。如果您不想公开它，请将其设置为私有：

struct Base {
     Base(Base &&) = default;
};

class Derived: public Base {
    Derived(Base &&b, int x): Base(std::move(b)), mX(x) {}
public:
    std::unique_ptr<Base> clone() const {
        auto retBase{Base::clone()};
        return std::make_unique<Derived>(std::move(*retBase), mX);
    }
};

---

例如，定义一个接受

Base

作为参数的附加构造函数。如果您不想公开它，请将其设置为私有：

struct Base {
     Base(Base &&) = default;
};

class Derived: public Base {
    Derived(Base &&b, int x): Base(std::move(b)), mX(x) {}
public:
    std::unique_ptr<Base> clone() const {
        auto retBase{Base::clone()};
        return std::make_unique<Derived>(std::move(*retBase), mX);
    }
};

---

正确地实现复制构造函数，那么每个克隆函数只需

返回std:：make_unique（*this）正确地实现复制构造函数，那么每个克隆函数只需
返回std:：make_unique（*this）谢谢你的多选，我想我会选择更简单的复制构造函数方法谢谢你的多选，我想我会选择更简单的复制构造函数方法我完全错过了这里的复制构造函数角色，我明白了，谢谢你的代码！我完全错过了这里的复制构造函数角色，我现在明白了，谢谢你的代码！
class Base {
protected:
    template<typename Concrete> std::unique_ptr<Base> recreate() const {
         std::unique_ptr<Base> retVal{std::make_unique<Concrete>()};
         // ???????
         return retVal;
    };
public:
    virtual std::unique_ptr<Base> clone() const { return recreate<Base>(); }
};

struct Derived: public Base {
    std::unique_ptr<Base> clone() const {
        auto retVal{recreate<Derived>()};
        retVal->mX = mX;
        return retVal;
    }
};