En C++, la gestion de la mémoire est effectuée à l'aide des opérateurs explicites new et delete, qui allouent et désallouent la mémoire de manière dynamique. Cependant, il est facile de provoquer des fuites de mémoire ou une double suppression lors de la gestion manuelle.
Avec l'arrivée de la norme C++11, des pointeurs intelligents ont été introduits — tels que std::unique_ptr, std::shared_ptr, std::weak_ptr. Ils gèrent automatiquement le cycle de vie des objets et garantissent la libération des ressources lorsque ceux-ci sortent de leur portée, même en cas d'exception.
Exemple de comparaison :
// Libération manuelle de la mémoire Foo* ptr = new Foo(); // ... delete ptr; // Plus sûr avec un pointeur intelligent std::unique_ptr<Foo> ptr2 = std::make_unique<Foo>(); // delete n'est pas nécessaire — tout sera géré par unique_ptr
Les pointeurs intelligents réduisent le risque de fuites de mémoire et rendent le code plus sûr et lisible.
Que se passe-t-il si vous appelez delete deux fois pour le même pointeur ?
Réponse : Après le premier appel à delete, la mémoire a déjà été libérée. Un appel répété entraînera un comportement indéfini (undefined behavior). Exemple :
Foo* p = new Foo(); delete p; delete p; // ERREUR !
Pour éviter cela, assignez nullptr au pointeur après sa libération :
delete p; p = nullptr;
Histoire
Dans un grand projet C++, un développeur a libéré manuellement la mémoire dynamique via
delete, oubliant de supprimer le pointeur en sortant de plusieurs branches de la fonction lors d'exceptions. Cela a conduit à des fuites de mémoire, détectées seulement lors des tests de charge.
Histoire
En essayant de partager des pointeurs bruts entre différentes parties du code, une double libération de la mémoire s'est produite — certaines parties du code ont fait
delete, sans en informer les autres. Résultat : segfault en production, l'analyse du core dump a immédiatement montré la cause.
Histoire
Après la migration d'un ancien projet vers de nouvelles normes C++, une partie du code avec des pointeurs bruts a été conservée, tandis que les nouvelles classes travaillaient déjà avec des pointeurs intelligents. Nous avons rencontré des erreurs de transmission de propriété des ressources : la mémoire était libérée "deux fois" — d'abord manuellement, puis automatiquement par les destructeurs des pointeurs intelligents.