AGGIORNARE
Questa risposta è piuttosto vecchia e descrive quindi ciò che era "buono" al momento, che era un puntatore intelligente fornito dalla libreria Boost. Dal momento che C ++ 11, la libreria standard ha fornito sufficienti tipi puntatori intelligenti, e così si dovrebbe favorire l'uso di std::unique_ptr, std::shared_ptre std::weak_ptr.
C'era anche std::auto_ptr. Era molto simile a un puntatore con ambito, tranne per il fatto che aveva anche la "speciale" pericolosa capacità di essere copiata, che trasferiva inaspettatamente la proprietà.
È stato deprecato in C ++ 11 e rimosso in C ++ 17 , quindi non dovresti usarlo.
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.
VECCHIA RISPOSTA
Un puntatore intelligente è una classe che avvolge un puntatore C ++ 'grezzo' (o 'nudo'), per gestire la durata dell'oggetto a cui si punta. Non esiste un singolo tipo di puntatore intelligente, ma tutti cercano di astrarre un puntatore non elaborato in modo pratico.
I puntatori intelligenti dovrebbero essere preferiti ai puntatori non elaborati. Se ritieni di dover usare i puntatori (prima considera se lo fai davvero ), normalmente vorresti usare un puntatore intelligente poiché questo può alleviare molti dei problemi con i puntatori non elaborati, dimenticandoti principalmente di eliminare l'oggetto e perdere memoria.
Con puntatori non elaborati, il programmatore deve distruggere esplicitamente l'oggetto quando non è più 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 puntatore intelligente al confronto definisce una politica su quando l'oggetto viene distrutto. Devi ancora creare l'oggetto, ma non devi più preoccuparti di distruggerlo.
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 politica più semplice in uso riguarda l'ambito dell'oggetto wrapper puntatore intelligente, come implementato da boost::scoped_ptro 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.
}
Si noti che le std::unique_ptristanze non possono essere copiate. Ciò impedisce che il puntatore venga eliminato più volte (in modo errato). Tuttavia, è possibile passare riferimenti ad esso ad altre funzioni chiamate.
std::unique_ptrsono utili quando si desidera associare la durata dell'oggetto a un determinato blocco di codice o se lo si è incorporato come dati membro all'interno di un altro oggetto, la durata di quell'altro oggetto. L'oggetto esiste fino all'uscita dal blocco di codice contenente o fino a quando l'oggetto contenitore non viene distrutto.
Una politica di puntatore intelligente più complessa prevede il conteggio dei riferimenti del puntatore. Ciò consente di copiare il puntatore. Quando l'ultimo "riferimento" all'oggetto viene distrutto, l'oggetto viene eliminato. Questa politica è implementata da boost::shared_ptre 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.
I puntatori contati di riferimento sono molto utili quando la durata del tuo oggetto è molto più complicata e non è legata direttamente a una particolare sezione di codice o ad un altro oggetto.
C'è un inconveniente per fare riferimento ai puntatori contati: la possibilità di creare un riferimento pendente:
// 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!
Un'altra possibilità è la creazione di riferimenti circolari:
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!
Per aggirare questo problema, sia Boost che C ++ 11 hanno definito a weak_ptrper definire un riferimento debole (non contato) a a shared_ptr.