Wie lösche Objekt, wenn Konstruktor eine Ausnahme auslöst?

Question

Also haben wir einen Konstruktor, der abhängig von den übergebenen Argumenten eine Exception auslösen kann, aber wir wissen nicht, wie man das Objekt löscht, wenn dies passiert. Wichtiger Teil des Codes:

try 
{ 
    GameBase *gameptr = GameBase::getGame(argc, argv); 
    if (gameptr == 0) 
    { 
     std::cout << "Correct usage: " << argv[PROGRAM_NAME] << " " << "TicTacToe" << std::endl; 
     return NO_GAME; 
    } 
    else 
    { 
     gameptr->play(); 
    } 
    delete gameptr; 
} 
catch (error e) 
{ 
    if (e == INVALID_DIMENSION) 
    { 
     std::cout << "Win condition is larger than the length of the board." << std::endl; 
     return e; 
    } 
} 
catch (...) 
{ 
    std::cout << "An exception was caught (probably bad_alloc from new operator)" << std::endl; 
    return GENERIC_ERROR; 
} 

In der dritten Zeile GameBase::getGame() ruft den Konstruktor für eines der Spiele, die von GameBase und gibt einen Zeiger auf dieses Spiel, und diese Konstrukteure können Ausnahmen werfen. Die Frage ist, wie können wir dann das (partielle?) Objekt löschen, auf das gameptr zeigt, wenn dies auftritt? Wenn eine Ausnahme ausgelöst wird, verlassen wir den Gültigkeitsbereich gameptr, weil wir den try-Block verlassen und delete gameptr nicht aufrufen können.

Answer 1

Um die Ausnahmesicherheit zu beurteilen, müssen Sie weitere Einzelheiten zur Konstruktion des Objekts in GameBase::getGame angeben.

Die Regel ist durch, dass, wenn ein Konstruktor wirft, das Objekt nicht erstellt wird, daher wird der Destruktor nicht aufgerufen. Zugehörige Speicherzuordnungen werden ebenfalls freigegeben (d. H. Der Speicher für das Objekt selbst).

Das Problem wird dann, wie war der Speicher für den Anfang zugeordnet? Wenn es mit einer new GameBase(...) war, dann ist es nicht notwendig, den resultierenden Zeiger zu entziehen oder zu löschen - der Speicher wird von der Laufzeit freigegeben.

---

Für Klarheit darüber, was mit den Membervariablen geschieht, die bereits konstruiert sind; Sie werden auf der Ausnahme des "Eltern" -Objekts zerstört. Betrachten Sie die sample code;

Der Ausgang ist;

M ctor 
C ctor 
M dtor 
std::exception 

---

Wenn das M m_ Mitglied ist dynamisch zugewiesen werden, bevorzugen unique_ptr oder ein shared_ptr über einen nackten Zeiger und erlauben den intelligenten Zeiger das Objekt für Sie zu verwalten; wie folgt;

#include <iostream> 
#include <memory> 
using namespace std; 
struct M { 
    M() { cout << "M ctor" << endl; } 
    ~M() { cout << "M dtor" << endl; } 
}; 
struct C { 
    unique_ptr<M> m_; 
    C() : m_(new M()) { cout << "C ctor" << endl; throw exception(); } 
    ~C() { cout << "C dtor" << endl; } 
}; 

Die Ausgabe spiegelt den obigen Ausgang wider.

Answer 2

Wenn Sie einen Konstruktor einwerfen, wird das Objekt nicht erstellt, und Sie sind daher für das Löschen zugewiesener Ressourcen verantwortlich. Das geht noch weiter! Betrachten Sie diesen Code

Es ist bis zu dem Compiler, in dem Reihenfolge ist die A zugeordnet und konstruiert. Sie könnten mit einem Speicherverlust enden, wenn Ihr A-Konstruktor werfen kann!

Edit: Verwenden statt

try{ 
auto first = std::make_unique<A>(); 
auto second = std::make_unique<A>(); 
int a = function(*first, *second); 
... 

Answer 3

Wenn Sie Foo* result = new Foo() schreiben, übersetzt der Compiler dies dem Äquivalent von diesem Code:

void* temp = operator new(sizeof(Foo)); // allocate raw memory 
try { 
    Foo* temp2 = new (temp) Foo(); // call constructor 
    result = temp2; 
} catch (...) { 
    operator delete(temp); // constructor threw, deallocate memory 
    throw; 
} 

Sie müssen also nicht über die zugewiesenen Sorge Speicher, wenn der Konstruktor wirft. Beachten Sie jedoch, dass dies nicht für zusätzlichen Speicher gilt, der im Konstruktor zugewiesen wurde.Destruktoren werden nur für Objekte aufgerufen, deren Konstruktor abgeschlossen ist. Daher sollten Sie alle Zuordnungen sofort in kleine Wrapper-Objekte (Smart Pointer) übernehmen.