ACTUALIZAR
Esta respuesta es bastante antigua, por lo que describe lo que era "bueno" en ese momento, que eran los punteros inteligentes proporcionados por la biblioteca Boost. Puesto que C ++ 11, la biblioteca estándar ha proporcionado suficientes tipos punteros inteligentes, y por lo que debería favorecer el uso de std::unique_ptr, std::shared_ptry std::weak_ptr.
También había std::auto_ptr . Era muy parecido a un puntero de alcance, excepto que también tenía la habilidad peligrosa "especial" de ser copiada, lo que también transfiere la propiedad inesperadamente.
Estaba en desuso en C ++ 11 y se eliminó en C ++ 17 , por lo que no debe 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.
ANTIGUA RESPUESTA
Un puntero inteligente es una clase que envuelve un puntero C ++ 'crudo' (o 'desnudo'), para administrar la vida útil del objeto al que se apunta. No existe un único tipo de puntero inteligente, pero todos intentan abstraer un puntero sin formato de manera práctica.
Se deben preferir los punteros inteligentes a los punteros en bruto. Si siente que necesita usar punteros (primero considere si realmente lo hace), normalmente querrá usar un puntero inteligente ya que esto puede aliviar muchos de los problemas con punteros sin procesar, principalmente olvidando eliminar el objeto y la pérdida de memoria.
Con punteros en bruto, el programador tiene que destruir explícitamente el objeto cuando ya no es útil.
// 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 puntero inteligente, en comparación, define una política sobre cuándo se destruye el objeto. Todavía tiene que crear el objeto, pero ya no tiene que preocuparse por destruirlo.
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 política más simple en uso implica el alcance del objeto contenedor de puntero inteligente, como el implementado por boost::scoped_ptrostd::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.
}
Tenga en cuenta que las std::unique_ptrinstancias no se pueden copiar. Esto evita que el puntero se elimine varias veces (incorrectamente). Sin embargo, puede pasar referencias a otras funciones que llame.
std::unique_ptrs son útiles cuando desea vincular la vida útil del objeto a un bloque de código en particular, o si lo incrusta como datos de miembros dentro de otro objeto, la vida útil de ese otro objeto. El objeto existe hasta que se sale del bloque de código que lo contiene, o hasta que el objeto que lo contiene se destruye.
Una política de puntero inteligente más compleja implica el recuento de referencias del puntero. Esto permite copiar el puntero. Cuando se destruye la última "referencia" al objeto, se elimina el objeto. Esta política es implementada por boost::shared_ptry 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.
Los punteros contados de referencia son muy útiles cuando la vida útil de su objeto es mucho más complicada y no está vinculada directamente a una sección particular de código ni a otro objeto.
Hay un inconveniente para hacer referencia a punteros contados: la posibilidad de crear una referencia colgante:
// 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!
Otra posibilidad es crear referencias circulares:
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!
Para evitar este problema, tanto Boost como C ++ 11 han definido a weak_ptrpara definir una referencia débil (sin contar) a a shared_ptr.