Wird der folgende Code Speicherverlust in C ++ verursachen?

Ja, es wird ein Speicherleck. Wenn der Konstruktor wirft, kein Destruktor aufgerufen wird (in diesem Fall Sie zeigen nicht einen Destruktor, befreit die dynamisch zugewiesenen Objekte, aber können davon ausgehen Sie hatte eine).

Dies ist ein wichtiger Grund für die Verwendung von smart-Pointer - da der smart poitners sind vollwertige Objekte, Sie erhalten Destruktoren aufgerufen, während der Ausnahme-Stapel entspannen und haben die Möglichkeit, den Speicher frei.

Wenn Sie so etwas wie Boost ' s scoped_ptr<> Vorlage Ihrer Klasse konnte sehen eher aus wie:

class base{
    int a;
    scoped_ptr<int> pint;
    someclass objsomeclass;
    scoped_ptr<someclass> psomeclass;
    base() : 
       pint( new int),
       objsomeclass( someclass()),
       psomeclass( new someclass())

    {
        throw "constructor failed";
        a = 43;
    }
}

Und Sie hätte keine Speicher-Lecks (und die Standard-dtor würde auch bereinigen die dynamische Zuweisung von Arbeitsspeicher).

Zusammenfassend (und hoffentlich auch die Antwort auf die Frage über die

base* temp = new base();

Anweisung):

Wenn eine Ausnahme geworfen wird in einem Konstruktor es gibt mehrere Dinge, die Sie sollten zur Kenntnis nehmen in Bezug auf die ordnungsgemäße Umgang mit Ressourcen bereitgestellt werden, die möglicherweise aufgetreten sind, in die abgebrochene Bau des Objekts:

1. der Destruktor für das Objekt gebaut wird nicht genannt werden.
2. Destruktor für die Objekte in das Objekt der Klasse aufgerufen werden
3. der Speicher für das Objekt, das gebaut wird befreit werden.

Dies bedeutet, dass wenn ein Objekt besitzt Ressourcen, die Sie haben 2 Möglichkeiten, um die bereinigen, die Ressourcen, die Sie vielleicht schon erworben wurde, wenn der Konstruktor wirft:

1. die Ausnahme abfangen, die Ressourcen freigeben, dann rethrow. Dies kann schwierig sein, um richtig und kann sich ein Pflege-problem.
2. Objekte zu verwalten, die Ressourcen der Lebensdauer (RAII) und verwenden Sie diese Objekte wie die Mitglieder. Wenn der Konstruktor des Objekts eine exception wirft, wird der member-Objekte wird desctructors genannt und haben die Möglichkeit, kostenlos die Ressource, deren Leben Sie verantwortlich sind.

InformationsquelleAutor der Antwort Michael Burr

Ich glaube, dass die top-Antwort ist falsch und würde immer noch ein Speicherleck.
Der Destruktor für die Klasse Mitglieder nicht werden aufgerufen, wenn der Konstruktor eine exception wirft (weil Sie nie Ihre Initialisierung abgeschlossen, und vielleicht einige Mitglieder haben noch nie erreichten Ihren Konstruktor-Aufrufe).
Die Destruktoren sind nur während der Klasse, die Destruktor-Aufruf. Das macht nur Sinn.

Dieses einfache Programm zeigt es.

#include <stdio.h>


class A
{
    int x;

public:
    A(int x) : x(x) { printf("A constructor [%d]\n", x); }
    ~A() { printf("A destructor [%d]\n", x); }
};


class B
{
    A a1;
    A a2;

public:
    B()
    :   a1(3),
        a2(5)
    {
        printf("B constructor\n");
        throw "failed";
    }
    ~B() { printf("B destructor\n"); }
};


int main()
{
    B b;

    return 0;
}

Mit der folgenden Ausgabe (mit g++ 4.5.2):

A constructor [3]
A constructor [5]
B constructor
terminate called after throwing an instance of 'char const*'
Aborted

Wenn der Konstruktor fehlschlägt Weg, dann ist es deine Verantwortung, damit umzugehen. Schlimmer noch, die Ausnahme, die ausgelöst werden können von Ihrer Basisklasse' Konstruktor!
Der Umgang mit diesen Fällen ist durch den Einsatz einer "Funktions-try-block" (aber selbst dann müssen Sie vorsichtig-code der Zerstörung Ihrer teilweise initialisiertes Objekt).

Den richtigen Ansatz für dein problem wäre dann so etwas wie dieses:

#include <stdio.h>


class A
{
    int x;

public:
    A(int x) : x(x) { printf("A constructor [%d]\n", x); }
    ~A() { printf("A destructor [%d]\n", x); }
};


class B
{
    A * a1;
    A * a2;

public:
    B()
    try  //<--- Notice this change
    :   a1(NULL),
        a2(NULL)
    {
        printf("B constructor\n");
        a1 = new A(3);
        throw "fail";
        a2 = new A(5);
    }
    catch ( ... ) {   //<--- Notice this change
        printf("B Cleanup\n");
        delete a2;  //It's ok if it's NULL.
        delete a1;  //It's ok if it's NULL.
    }

    ~B() { printf("B destructor\n"); }
};


int main()
{
    B b;

    return 0;
}

Wenn Sie es ausführen, Sie erhalten die erwartete Ausgabe, bei der nur die zugewiesenen Objekte sind zerstört und befreit.

B constructor
A constructor [3]
B Cleanup
A destructor [3]
terminate called after throwing an instance of 'char const*'
Aborted

Können Sie immer noch arbeiten Sie mit smart shared Pointer, wenn Sie wollen, mit zusätzlichen kopieren. Schreiben Sie einen Konstruktor, ähnlich diesem:

class C
{
    std::shared_ptr<someclass> a1;
    std::shared_ptr<someclass> a2;

public:
    C()
    {
        std::shared_ptr<someclass> new_a1(new someclass());
        std::shared_ptr<someclass> new_a2(new someclass());

        //You will reach here only if both allocations succeeded. Exception will free them both since they were allocated as automatic variables on the stack.
        a1 = new_a1;
        a2 = new_a2;
    }
}

Glück,
Tzvi.

InformationsquelleAutor der Antwort

Ja, dass der code ein Speicherleck. Die Blöcke des Speichers über "neue" werden nicht freigegeben, wenn eine Ausnahme ausgelöst wird. Dies ist ein Teil der motivation hinter RAII.

Zu vermeiden, die Speicherverlust, probieren Sie etwas wie dieses:

psomeclass = NULL;
pint = NULL;
/* So on for any pointers you allocate */

try {
    objsomeclass = someclass();
    psomeclass = new someclass();
    pint = new int(); 
    throw "constructor failed";
    a = 43;
 }
 catch (...)
 {
     delete psomeclass;
     delete pint;
     throw;
 }

InformationsquelleAutor der Antwort John Millikin

müssen Sie löschen psomeclass... es ist nicht notwendig, zu bereinigen, die integer...

RWendi

InformationsquelleAutor der Antwort RWendi