ATUALIZAR
Essa resposta é bastante antiga e, portanto, descreve o que era 'bom' na época, que eram indicadores inteligentes fornecidos pela biblioteca Boost. Desde o C ++ 11, a biblioteca padrão fornece tipos suficientes de ponteiros inteligentes e, portanto, você deve favorecer o uso de std::unique_ptr, std::shared_ptre std::weak_ptr.
Havia também std::auto_ptr. Era muito parecido com um ponteiro de escopo, exceto que também tinha a capacidade perigosa "especial" de ser copiada - o que também transfere inesperadamente a propriedade.
Ele foi descontinuado no C ++ 11 e removido no C ++ 17 , portanto, você não deve usá-lo.
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.
RESPOSTA ANTIGA
Um ponteiro inteligente é uma classe que agrupa um ponteiro C ++ 'bruto' (ou 'vazio'), para gerenciar a vida útil do objeto que está sendo apontado. Não há um tipo de ponteiro inteligente único, mas todos tentam abstrair um ponteiro bruto de maneira prática.
Ponteiros inteligentes devem ter preferência sobre ponteiros brutos. Se você acha que precisa usar ponteiros (primeiro considere se realmente o faz), normalmente deseja usar um ponteiro inteligente, pois isso pode aliviar muitos dos problemas com ponteiros brutos, principalmente esquecendo de excluir o objeto e vazar memória.
Com ponteiros brutos, o programador precisa destruir explicitamente o objeto quando ele não é mais ú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...?
Um ponteiro inteligente por comparação define uma política para quando o objeto é destruído. Você ainda precisa criar o objeto, mas não precisa mais se preocupar em destruí-lo.
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
A política mais simples em uso envolve o escopo do objeto wrapper do ponteiro inteligente, como implementado por 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.
}
Observe que as std::unique_ptrinstâncias não podem ser copiadas. Isso evita que o ponteiro seja excluído várias vezes (incorretamente). No entanto, você pode passar referências a ele para outras funções chamadas.
std::unique_ptrs são úteis quando você deseja vincular a vida útil do objeto a um bloco de código específico, ou se você o incorporou como dados do membro em outro objeto, a vida útil desse outro objeto. O objeto existe até que o bloco de código contido seja encerrado ou até que o próprio objeto contido seja destruído.
Uma política de ponteiro inteligente mais complexa envolve a contagem de referência do ponteiro. Isso permite que o ponteiro seja copiado. Quando a última "referência" ao objeto é destruída, o objeto é excluído. Esta política é implementada por 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.
Os ponteiros contados por referência são muito úteis quando a vida útil do seu objeto é muito mais complicada e não está vinculada diretamente a uma seção específica do código ou a outro objeto.
Há uma desvantagem em referenciar ponteiros contados - a possibilidade de criar uma referência 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!
Outra possibilidade é criar referências 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 contornar esse problema, o Boost e o C ++ 11 definiram a weak_ptrpara definir uma referência fraca (não contada) para a shared_ptr.