Warum verursacht die Verwendung von "neu" Speicherlecks?

Ich habe zuerst C # gelernt und jetzt beginne ich mit C ++. Soweit ich weiß, newähnelt der Operator in C ++ nicht dem in C #.

Können Sie den Grund für den Speicherverlust in diesem Beispielcode erklären?

class A { ... };
struct B { ... };

A *object1 = new A();
B object2 = *(new B());

Was ist los

Wenn Sie schreiben T t;, erstellen Sie ein Objekt vom Typ Tmit automatischer Speicherdauer . Es wird automatisch bereinigt, wenn es außerhalb des Gültigkeitsbereichs liegt.

Beim Schreiben new T()erstellen Sie ein Objekt vom Typ Tmit dynamischer Speicherdauer . Es wird nicht automatisch aufgeräumt.

Sie müssen einen Zeiger darauf übergeben, deleteum es zu bereinigen:

Ihr zweites Beispiel ist jedoch schlechter: Sie dereferenzieren den Zeiger und erstellen eine Kopie des Objekts. Auf diese Weise verlieren Sie den Zeiger auf das mit erstellte Objekt new, sodass Sie es niemals löschen können, selbst wenn Sie möchten!

Was du machen solltest

Sie sollten die automatische Speicherdauer bevorzugen. Benötigen Sie ein neues Objekt, schreiben Sie einfach:

A a; // a new object of type A
B b; // a new object of type B

Wenn Sie eine dynamische Speicherdauer benötigen, speichern Sie den Zeiger auf das zugewiesene Objekt in einem Objekt mit automatischer Speicherdauer, das es automatisch löscht.

template <typename T>
class automatic_pointer {
public:
    automatic_pointer(T* pointer) : pointer(pointer) {}

    // destructor: gets called upon cleanup
    // in this case, we want to use delete
    ~automatic_pointer() { delete pointer; }

    // emulate pointers!
    // with this we can write *p
    T& operator*() const { return *pointer; }
    // and with this we can write p->f()
    T* operator->() const { return pointer; }

private:
    T* pointer;

    // for this example, I'll just forbid copies
    // a smarter class could deal with this some other way
    automatic_pointer(automatic_pointer const&);
    automatic_pointer& operator=(automatic_pointer const&);
};

automatic_pointer<A> a(new A()); // acts like a pointer, but deletes automatically
automatic_pointer<B> b(new B()); // acts like a pointer, but deletes automatically

Dies ist eine gebräuchliche Redewendung, die unter dem nicht sehr beschreibenden Namen RAII ( Resource Acquisition Is Initialization ) geführt wird. Wenn Sie eine Ressource erwerben, die bereinigt werden muss, stecken Sie sie in ein Objekt mit automatischer Speicherdauer, damit Sie sich nicht um die Bereinigung kümmern müssen. Dies gilt für jede Ressource, sei es Speicher, geöffnete Dateien, Netzwerkverbindungen oder was auch immer Sie möchten.

Dieses automatic_pointerDing existiert bereits in verschiedenen Formen, ich habe es nur bereitgestellt, um ein Beispiel zu geben. Eine sehr ähnliche Klasse existiert in der Standardbibliothek namens std::unique_ptr.

Es gibt auch eine alte (vor C ++ 11) mit dem Namen auto_ptr, die jetzt jedoch veraltet ist, da sie ein seltsames Kopierverhalten aufweist.

Und dann gibt es einige noch intelligentere Beispiele, std::shared_ptrdie mehrere Zeiger auf dasselbe Objekt zulassen und es erst bereinigen, wenn der letzte Zeiger zerstört wird.

Eine schrittweise Erklärung:

// creates a new object on the heap:
new B()
// dereferences the object
*(new B())
// calls the copy constructor of B on the object
B object2 = *(new B());

Am Ende haben Sie also ein Objekt auf dem Heap ohne Zeiger darauf, sodass es nicht gelöscht werden kann.

Das andere Beispiel:

A *object1 = new A();

ist nur dann ein Speicherverlust, wenn Sie deleteden zugewiesenen Speicher vergessen haben :

delete object1;

In C ++ gibt es Objekte mit automatischem Speicher, auf dem Stapel erstellte Objekte, die automatisch entsorgt werden, und Objekte mit dynamischem Speicher auf dem Heap, denen Sie zuordnen newund mit denen Sie sich befreien müssen delete. (das ist alles grob ausgedrückt)

Denken Sie, dass Sie deletefür jedes Objekt eine zuweisen sollten new.

BEARBEITEN

Kommen Sie, um darüber nachzudenken, object2muss kein Speicherverlust sein.

Der folgende Code dient nur dazu, einen Punkt zu verdeutlichen. Es ist eine schlechte Idee, Code wie diesen niemals zu mögen:

class B
{
public:
    B() {};   //default constructor
    B(const B& other) //copy constructor, this will be called
                      //on the line B object2 = *(new B())
    {
        delete &other;
    }
}

In diesem Fall ist es, da otheres als Referenz übergeben wird, das genaue Objekt, auf das von gezeigt wird new B(). Daher &otherwürde das Abrufen der Adresse durch und das Löschen des Zeigers den Speicher freigeben.

Aber ich kann das nicht genug betonen, tu das nicht. Es ist nur hier, um einen Punkt zu machen.

Gegeben zwei "Objekte":

obj a;
obj b;

Sie werden nicht denselben Speicherort belegen. Mit anderen Worten,&a != &b

Wenn Sie den Wert des einen dem anderen zuweisen, ändert sich nicht der Speicherort, sondern der Inhalt:

obj a;
obj b = a;
//a == b, but &a != &b

Intuitiv funktionieren Zeiger- "Objekte" auf die gleiche Weise:

obj *a;
obj *b = a;
//a == b, but &a != &b

Schauen wir uns nun Ihr Beispiel an:

A *object1 = new A();

Dies weist den Wert von zu new A() zu object1. Der Wert ist ein Zeiger, was bedeutet object1 == new A(), aber &object1 != &(new A()). (Beachten Sie, dass dieses Beispiel kein gültiger Code ist, sondern nur zur Erläuterung dient.)

Da der Wert des Zeigers erhalten bleibt, können wir den Speicher freigeben, auf den er verweist: delete object1;Aufgrund unserer Regel verhält sich dies genauso wie delete (new A());bei keinem Leck.

In Ihrem zweiten Beispiel kopieren Sie das Objekt, auf das Sie zeigen. Der Wert ist der Inhalt dieses Objekts, nicht der eigentliche Zeiger. Wie in jedem anderen Fall&object2 != &*(new A()) .

B object2 = *(new B());

Wir haben den Zeiger auf den zugewiesenen Speicher verloren und können ihn daher nicht freigeben. delete &object2;mag scheinen, als würde es funktionieren, aber weil &object2 != &*(new A())es nicht gleichwertig delete (new A())und so ungültig ist.

In C # und Java verwenden Sie new, um eine Instanz einer Klasse zu erstellen, und müssen sich dann nicht mehr darum kümmern, sie später zu zerstören.

C ++ hat auch ein Schlüsselwort "new", das ein Objekt erstellt. Im Gegensatz zu Java oder C # ist dies jedoch nicht die einzige Möglichkeit, ein Objekt zu erstellen.

C ++ verfügt über zwei Mechanismen zum Erstellen eines Objekts:

• automatisch
• dynamisch

Bei der automatischen Erstellung erstellen Sie das Objekt in einer Umgebung mit Gültigkeitsbereich: - in einer Funktion oder - als Mitglied einer Klasse (oder Struktur).

In einer Funktion würden Sie es folgendermaßen erstellen:

int func()
{
   A a;
   B b( 1, 2 );
}

Innerhalb einer Klasse würden Sie es normalerweise so erstellen:

class A
{
  B b;
public:
  A();
};    

A::A() :
 b( 1, 2 )
{
}

Im ersten Fall werden die Objekte beim Verlassen des Bereichsblocks automatisch zerstört. Dies kann eine Funktion oder ein Scope-Block innerhalb einer Funktion sein.

Im letzteren Fall wird das Objekt b zusammen mit der Instanz von A zerstört, in der es Mitglied ist.

Objekte werden mit new zugewiesen, wenn Sie die Lebensdauer des Objekts steuern müssen. Anschließend muss es gelöscht werden, um es zu zerstören. Mit der als RAII bekannten Technik kümmern Sie sich um das Löschen des Objekts an dem Punkt, an dem Sie es erstellen, indem Sie es in ein automatisches Objekt einfügen, und warten, bis der Destruktor des automatischen Objekts wirksam wird.

Ein solches Objekt ist ein shared_ptr, das eine "Löscher" -Logik aufruft, jedoch nur dann, wenn alle Instanzen des shared_ptr, die das Objekt gemeinsam nutzen, zerstört werden.

Während Ihr Code möglicherweise viele Aufrufe von new enthält, sollten Sie im Allgemeinen nur begrenzte Aufrufe zum Löschen haben und immer sicherstellen, dass diese von Destruktoren aufgerufen oder Objekte "gelöscht" werden, die in Smart-Pointer eingefügt werden.

Ihre Destruktoren sollten auch niemals Ausnahmen auslösen.

Wenn Sie dies tun, treten nur wenige Speicherlecks auf.

B object2 = *(new B());

Diese Leitung ist die Ursache für das Leck. Lassen Sie uns dies ein wenig auseinander nehmen ..

Objekt2 ist eine Variable vom Typ B, die beispielsweise an Adresse 1 gespeichert ist (Ja, ich wähle hier beliebige Zahlen aus). Auf der rechten Seite haben Sie nach einem neuen B oder einem Zeiger auf ein Objekt vom Typ B gefragt. Das Programm gibt Ihnen dies gerne und weist Ihr neues B der Adresse 2 zu und erstellt auch einen Zeiger in der Adresse 3. Nun Der einzige Weg, auf die Daten in Adresse 2 zuzugreifen, ist über den Zeiger in Adresse 3. Als nächstes haben Sie den Zeiger mit dereferenziert* , um die Daten auf die der Zeiger zeigt (die Daten in Adresse 2). Dadurch wird effektiv eine Kopie dieser Daten erstellt und Objekt2 zugewiesen, das in Adresse 1 zugewiesen ist. Denken Sie daran, dass es sich um eine KOPIE handelt, nicht um das Original.

Hier ist das Problem:

Sie haben diesen Zeiger nie an einem Ort gespeichert, an dem Sie ihn verwenden können! Sobald diese Zuweisung abgeschlossen ist, ist der Zeiger (Speicher in Adresse3, über den Sie auf Adresse2 zugegriffen haben) außerhalb des Bereichs und außerhalb Ihrer Reichweite! Sie können delete nicht mehr aufrufen und daher den Speicher in Adresse2 nicht bereinigen. Was Ihnen bleibt, ist eine Kopie der Daten von Adresse2 in Adresse1. Zwei der gleichen Dinge, die in Erinnerung bleiben. Auf eines können Sie zugreifen, auf das andere nicht (weil Sie den Pfad dorthin verloren haben). Deshalb ist dies ein Speicherverlust.

Ich würde vorschlagen, dass Sie aus Ihrem C # -Hintergrund viel darüber lesen, wie Zeiger in C ++ funktionieren. Sie sind ein fortgeschrittenes Thema und können einige Zeit in Anspruch nehmen, aber ihre Verwendung wird für Sie von unschätzbarem Wert sein.

Wenn es einfacher ist, stellen Sie sich den Computerspeicher wie ein Hotel vor, und Programme sind Kunden, die Zimmer mieten, wenn sie diese benötigen.

Dieses Hotel funktioniert so, dass Sie ein Zimmer buchen und dem Portier mitteilen, wann Sie abreisen.

Wenn Sie Bücher buchen und einen Raum verlassen, ohne dies dem Portier mitzuteilen, wird der Portier denken, dass der Raum noch genutzt wird, und niemand anderem erlauben, ihn zu benutzen. In diesem Fall liegt ein Raumleck vor.

Wenn Ihr Programm Speicher zuweist und ihn nicht löscht (es verwendet ihn lediglich nicht mehr), glaubt der Computer, dass der Speicher noch verwendet wird, und lässt niemanden zu, ihn zu verwenden. Dies ist ein Speicherverlust.

Dies ist keine exakte Analogie, aber es könnte helfen.

Beim Erstellen erstellen object2Sie eine Kopie des Objekts, das Sie mit new erstellt haben, verlieren jedoch auch den (nie zugewiesenen) Zeiger (sodass Sie ihn später nicht mehr löschen können). Um dies zu vermeiden, müssten Sie object2eine Referenz erstellen.

Nun, Sie erstellen einen Speicherverlust, wenn Sie den mit dem newOperator zugewiesenen Speicher nicht irgendwann freigeben, indem Sie dem Operator einen Zeiger auf diesen Speicher übergeben delete.

In Ihren beiden oben genannten Fällen:

A *object1 = new A();

Hier wird deleteder Speicher nicht freigegeben. Wenn also Ihr object1Zeiger den Gültigkeitsbereich verlässt, tritt ein Speicherverlust auf, da Sie den Zeiger verloren haben und daher den deleteOperator nicht verwenden können.

Und hier

B object2 = *(new B());

Sie verwerfen den von zurückgegebenen Zeiger new B()und können diesen Zeiger daher niemals an übergeben, damit deleteder Speicher freigegeben wird. Daher ein weiterer Speicherverlust.

Es ist diese Linie, die sofort leckt:

B object2 = *(new B());

Hier erstellen Sie ein neues BObjekt auf dem Heap und anschließend eine Kopie auf dem Stapel. Auf diejenige, die auf dem Heap zugewiesen wurde, kann nicht mehr zugegriffen werden, und daher das Leck.

Diese Leitung ist nicht sofort undicht:

A *object1 = new A();

Es wäre ein Leck sein , wenn Sie nie deleted object1though.