Wie vermeide ich Speicherlecks mit Vektoren von Zeigern in C?

Vermeiden von Speicherlecks mit Zeigervektoren in C

Beim Arbeiten mit dynamischer Speicherzuweisung ist es entscheidend, Speicherlecks zu verhindern. Ein häufiges Szenario beinhaltet die Verwendung eines Vektors von Zeigern auf Objekte, die von einer Basisklasse abgeleitet sind.

Vektor von Zeigern und Speicherverwaltung

std::vector verwaltet den Speicher für die Zeiger, nicht jedoch für die Objekte selbst. Dies bedeutet, dass über die push_back()-Methode des Vektors zugewiesene Objekte nicht automatisch gelöscht werden, wenn der Vektor den Gültigkeitsbereich verlässt.

Speicherlecks vermeiden

1. Manuelles Löschen von Objekten:

Dieser Ansatz erfordert das manuelle Löschen jedes Objekts, bevor der Vektor den Gültigkeitsbereich verlässt, wie im folgenden Code gezeigt:

#include <vector>

struct base {
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<base*> container;

void foo() {
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(new derived());

    // Manual object deletion
    for (auto& obj : c)
        delete obj;
}

2. Smart Pointer:

Eine Alternative ist die Verwendung von Smart Pointern, die eine automatische Speicherverwaltung ermöglichen. std::unique_ptr und std::shared_ptr sind häufig verwendete intelligente Zeiger:

std::unique_ptr:

Ein unique_ptr repräsentiert den alleinigen Besitz einer Ressource. Das Objekt wird automatisch gelöscht, wenn es den Gültigkeitsbereich verlässt.

#include <vector>
#include <memory>

struct base {
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<std::unique_ptr<base>> container;

void foo() {
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(std::make_unique<derived>());
}

std::shared_ptr:

Ein shared_ptr ermöglicht mehreren Eigentümern die gemeinsame Nutzung einer Ressource. Es verfolgt die Anzahl der Besitzer und löscht das Objekt, wenn der Referenzzähler Null erreicht.

#include <vector>
#include <memory>

struct base {
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<std::shared_ptr<base>> container;

void foo() {
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(std::make_shared<derived>());
}

3. Boost::ptr_container:

Boost::ptr_container::ptr_vector ist ein spezieller Container, der Zeiger speichert und bei Zerstörung automatisch löscht:

#include <boost/ptr_container/ptr_vector.hpp>

struct base {
    virtual ~base() {}
};

struct derived : base {};

typedef boost::ptr_vector<base> container;

void foo() {
    container c;

    for (int i = 0; i < 100; ++i)
        c.push_back(new Derived());
}

Denken Sie daran, dass dies allgemein empfohlen wird die Verwendung intelligenter Zeiger (insbesondere std::unique_ptr), da diese eine automatische, ausnahmesichere Speicherverwaltung ermöglichen. Vermeiden Sie das manuelle Löschen von Objekten und stellen Sie sicher, dass Ressourcen immer dann freigegeben werden, wenn sie nicht mehr benötigt werden, um Speicherlecks und unvorhersehbares Verhalten in Ihrem Code zu verhindern.

Das obige ist der detaillierte Inhalt vonWie vermeide ich Speicherlecks mit Vektoren von Zeigern in C?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!