c++ - 如何在 C++ 中备份/克隆对象

Question

我在 C++ 中有一个类 SRecord 和这样的对象

SRecord* CurrentCmnd;

CurrentCmnd = theStack->Pop(dig, operation1, resp_sol);

我想在这里备份CurrentCmd

CurrentCmnd = theStack->Pop(dig, operation2, resp_sol);

在此操作之后，我想使用从第一个 Pop 操作返回的 CurrentCmnd，以便我可以对 CurrentCmnd 执行其他检查.

在从堆栈中弹出第二个元素之前，如何备份上面的 CurrentCmnd。

还要提一下，我不能继承SRecord类，不能使用拷贝构造函数。

我正在寻找类似下面的解决方案

 CurrentCmnd = theStack->Pop(dig, operation1, resp_sol);

CurrentCmnd 的备份。

SRecord* Temp_CurrentCmnd = CurrentCmnd;

CurrentCmnd = theStack->Pop(dig, operation2, resp_sol);

CurrentCmnd = Temp_CurrentCmnd;

Answer 1

这里有一些可能的方法来实现，所有的方法都假设类有一个复制构造函数

简单地使用复制构造函数

您可以使用它即时创建拷贝。

创建动态分配的拷贝(不要忘记在完成后释放内存):

SRecord * copy = new SRecord(*CurrentCmnd);

创建一个本地拷贝(这个拷贝将只存在于整个方法的范围内):

SRecord copy(*CurrentCmd);

为对象添加克隆方法

一个干净的实现方法是将以下方法添加到 SRecord:

class SRecord {
     public:
         SRecord * createBackup() { return new Object(*this); }
}

然后你可以调用:

SRecord * CurrentCmndBackup = CurrentCmnd->createBackup();

不要忘记在完成后释放备份:)

通用实现

在我的项目中，我通常将这个方法添加到一些我可以在以后继承的基类中。它看起来像这样:

class Cloneable {
     public:
         virtual Cloneable * clone() = 0;
}

class SRecord : public Cloneable {
     public:
         virtual Cloneable * clone() { return new SRecord(*this); }
}

智能指针实现

一个更简洁的实现使用智能指针。在我的大多数项目中，我发现这些对象是我想传递给其他模块的东西，所以我使用了共享指针，但唯一的指针实现也是合法的。

这是它的样子:

class Cloneable {
    public:
        using Sptr = std::shared_ptr<Cloneable>;
        virtual Sptr clone() = 0;
};

class SRecord : public Cloneable {
    public:
        using Sptr = std::shared_ptr<SRecord>;
        virtual Cloneable::Sptr clone() { return std::static_pointer_cast<Cloneable>(std::make_shared<SRecord>(*this)); }
};

int main()
{
    SRecord::Sptr a = std::make_shared<SRecord>();
    SRecord::Sptr b = std::static_pointer_cast<SRecord>(a->clone());
}

模板化实现

正如所建议的，另一个实现是使用不属于任何对象的模板化克隆方法:

template < typename T >
std::shared_ptr<T> clone(const T & obj) {
    return std::make_shared<T>(obj);
}