Comment éviter les fuites de mémoire avec les vecteurs de pointeurs en C ?

Éviter les fuites de mémoire avec des vecteurs de pointeurs en C

Lorsque vous travaillez avec une allocation dynamique de mémoire, il est crucial d'éviter les fuites de mémoire. Un scénario courant implique l'utilisation d'un vecteur de pointeurs vers des objets dérivés d'une classe de base.

Vecteur de pointeurs et de gestion de la mémoire

std::vector gère la mémoire des pointeurs, mais pas des objets eux-mêmes. Cela signifie que les objets alloués via la méthode push_back() du vecteur ne seront pas automatiquement supprimés lorsque le vecteur sort de la portée.

Éviter les fuites de mémoire

1. Suppression manuelle d'objets :

Cette approche nécessite la suppression manuelle de chaque objet avant que le vecteur ne sorte de la portée, comme démontré dans le code ci-dessous :

#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. Pointeurs intelligents :

Une alternative consiste à utiliser des pointeurs intelligents, qui assurent une gestion automatique de la mémoire. std::unique_ptr et std::shared_ptr sont des pointeurs intelligents couramment utilisés :

std::unique_ptr:

Un unique_ptr représente la propriété exclusive d'une ressource. Il supprime automatiquement l'objet lorsqu'il est hors de portée.

#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:

Un shared_ptr permet à plusieurs propriétaires de partager une ressource. Il garde une trace du nombre de propriétaires et supprime l'objet lorsque le nombre de références atteint zéro.

#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 est un conteneur spécialisé conçu pour contenir des pointeurs et les supprimer automatiquement lors de leur destruction :

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

N'oubliez pas qu'il est généralement recommandé d'utiliser des pointeurs intelligents (en particulier std::unique_ptr) car ils assurent une gestion automatique de la mémoire sans exception. Évitez la suppression manuelle d'objets et assurez-vous que les ressources sont toujours désallouées lorsqu'elles ne sont plus nécessaires pour éviter les fuites de mémoire et les comportements imprévisibles dans votre code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!