Question

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

SRecord* CurrentCmnd;

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

我想在这里备份CurrentCmd

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

在此操作之后，我想使用从第一个CurrentCmnd操作返回的Pop，以便我可以对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);
}

如何在c ++中

1 个答案: