MISE À JOUR
Cette réponse est plutôt ancienne et décrit donc ce qui était «bon» à l'époque, à savoir les pointeurs intelligents fournis par la bibliothèque Boost. Depuis C ++ 11, la bibliothèque standard a fourni suffisamment de types de pointeurs intelligents, et vous devriez donc privilégier l'utilisation de std::unique_ptr, std::shared_ptret std::weak_ptr.
Il y en avait aussi std::auto_ptr. Il ressemblait beaucoup à un pointeur de portée, sauf qu'il avait également la capacité dangereuse «spéciale» à copier - qui transfère également de manière inattendue la propriété.
Il était obsolète en C ++ 11 et supprimé en C ++ 17 , vous ne devriez donc pas l'utiliser.
std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership.
// p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.
RÉPONSE ANCIENNE
Un pointeur intelligent est une classe qui encapsule un pointeur C ++ «brut» (ou «nu»), pour gérer la durée de vie de l'objet pointé. Il n'y a pas de type de pointeur intelligent unique, mais tous essaient d'abstraire un pointeur brut de manière pratique.
Les pointeurs intelligents devraient être préférés aux pointeurs bruts. Si vous pensez que vous devez utiliser des pointeurs (pensez d'abord si vous le faites vraiment ), vous voudrez normalement utiliser un pointeur intelligent car cela peut atténuer de nombreux problèmes avec les pointeurs bruts, oubliant principalement de supprimer l'objet et les fuites de mémoire.
Avec des pointeurs bruts, le programmeur doit détruire explicitement l'objet lorsqu'il n'est plus utile.
// Need to create the object to achieve some goal
MyObject* ptr = new MyObject();
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?
Un pointeur intelligent par comparaison définit une politique quant au moment où l'objet est détruit. Vous devez toujours créer l'objet, mais vous n'avez plus à vous soucier de le détruire.
SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.
// Destruction of the object happens, depending
// on the policy the smart pointer class uses.
// Destruction would happen even if DoSomething()
// raises an exception
La stratégie la plus simple utilisée implique la portée de l'objet wrapper de pointeur intelligent, tel qu'implémenté par boost::scoped_ptrou std::unique_ptr.
void f()
{
{
std::unique_ptr<MyObject> ptr(new MyObject());
ptr->DoSomethingUseful();
} // ptr goes out of scope --
// the MyObject is automatically destroyed.
// ptr->Oops(); // Compile error: "ptr" not defined
// since it is no longer in scope.
}
Notez que les std::unique_ptrinstances ne peuvent pas être copiées. Cela empêche le pointeur d'être supprimé plusieurs fois (incorrectement). Vous pouvez cependant lui transmettre des références à d'autres fonctions que vous appelez.
std::unique_ptrs sont utiles lorsque vous souhaitez lier la durée de vie de l'objet à un bloc de code particulier, ou si vous l'avez incorporé en tant que données de membre dans un autre objet, la durée de vie de cet autre objet. L'objet existe jusqu'à ce que le bloc contenant du code soit quitté ou jusqu'à ce que l'objet contenant soit lui-même détruit.
Une stratégie de pointeur intelligent plus complexe implique le comptage des références du pointeur. Cela permet de copier le pointeur. Lorsque la dernière "référence" à l'objet est détruite, l'objet est supprimé. Cette politique est mise en œuvre par boost::shared_ptret std::shared_ptr.
void f()
{
typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
MyObjectPtr p1; // Empty
{
MyObjectPtr p2(new MyObject());
// There is now one "reference" to the created object
p1 = p2; // Copy the pointer.
// There are now two references to the object.
} // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero.
// The object is deleted.
Les pointeurs comptés par référence sont très utiles lorsque la durée de vie de votre objet est beaucoup plus compliquée et n'est pas directement liée à une section particulière de code ou à un autre objet.
Il y a un inconvénient à référencer les pointeurs comptés - la possibilité de créer une référence pendante:
// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!
Une autre possibilité consiste à créer des références circulaires:
struct Owner {
std::shared_ptr<Owner> other;
};
std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1
// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!
Pour contourner ce problème, Boost et C ++ 11 ont défini a weak_ptrpour définir une référence faible (non comptée) à a shared_ptr.