Wie ein Backup/Klonen des Objekts in c nehmen ++

Question

ich eine Klasse, Ich möchte die CurrentCmnd verwenden, die von der ersten Pop Operation zurückkehrt, damit ich andere Überprüfungen auf CurrentCmnd durchführen kann.

Wie kann ich eine Sicherungskopie der oben genannten CurrentCmnd vor dem Aufspringen des zweiten Elements aus dem Stapel.

Auch möchte ich erwähnen, dass ich die SRecord Class nicht erben kann, kann nicht kopieren Konstruktor.

Ich suche die Lösung so etwas wie unten

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

Sicherung von CurrentCmnd.

SRecord* Temp_CurrentCmnd = CurrentCmnd; 

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

CurrentCmnd = Temp_CurrentCmnd; 

Answer 1

Hier sind einige Möglichkeiten, das zu erreichen, müssen alle Methoden übernehmen die Klasse eine Kopie Konstruktor könnte

einfach eine Kopie Konstruktor

Sie verwenden es nur eine Kopie auf erstellen -die Fliege.

eine dynamisch zugewiesene Kopie erstellen (vergessen Sie nicht, den Speicher frei, sobald Sie damit fertig sind):

SRecord * copy = new SRecord(*CurrentCmnd); 

eine lokale Kopie erstellen (diese Kopie wird existiert nur im ganzen Umfang des Verfahrens) :

SRecord copy(*CurrentCmd); 

eine saubere Art und Weise ein Klon-Methode für das Objekt Addiert man diese zu implementieren ist, die fo hinzufügen llowing Methode SRecord:

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

Dann können Sie einfach anrufen:

SRecord * CurrentCmndBackup = CurrentCmnd->createBackup(); 

Vergessen Sie nicht, um die Sicherung zu befreien, wenn Sie mit ihm fertig sind :)

Generika Umsetzung

In meinen Projekten füge ich diese Methode normalerweise zu einer Basisklasse hinzu, aus der ich später erben kann. Es sieht wie folgt aus:

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

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

Smart Pointer Implementierung

Eine noch sauberere Implementierung Smart-Pointer verwendet.In den meisten meiner Projekte habe ich festgestellt, dass diese Objekte etwas sind, das ich gerne an andere Module weitergeben würde. Daher habe ich geteilte Zeiger verwendet, aber eine einzigartige Pointer-Implementierung ist auch richtig.

Hier ist, wie es aussieht:

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()); 
} 

Templated Implementierung

Wie vorgeschlagen, eine zusätzliche Implementierung wird eine Templat-Klon-Methode, die nicht Teil eines Objekts ist:

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