O que é um ponteiro inteligente e quando devo usar um?

O que é um ponteiro inteligente e quando devo usar um?

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.

Aqui está uma resposta simples para esses dias do C ++ moderno (C ++ 11 e posterior):

• O que é um ponteiro inteligente?
  É um tipo cujos valores podem ser usados ​​como ponteiros, mas que fornece o recurso adicional do gerenciamento automático de memória: Quando um ponteiro inteligente não está mais em uso, a memória para a qual ele aponta é desalocada (consulte também a definição mais detalhada na Wikipedia ).
• Quando devo usar um?
  No código que envolve rastrear a propriedade de um pedaço de memória, alocar ou desalocar; o ponteiro inteligente geralmente evita a necessidade de fazer essas coisas explicitamente.
• Mas qual ponteiro inteligente devo usar em qual desses casos?
  • Use std::unique_ptrquando não pretender manter várias referências ao mesmo objeto. Por exemplo, use-o como um ponteiro para a memória que é alocado na entrada de algum escopo e desalocado na saída do escopo.
  • Use std::shared_ptrquando quiser se referir ao seu objeto a partir de vários locais - e não deseja que seu objeto seja desalocado até que todas essas referências tenham desaparecido.
  • Use std::weak_ptrquando você quiser se referir ao seu objeto de vários lugares - para aquelas referências para as quais não há problema em ignorar e desalocar (para que elas notem que o objeto desapareceu quando você tenta desreferenciar).
  • Não use os boost::ponteiros inteligentes ou, std::auto_ptrexceto em casos especiais, os quais você pode ler se precisar.
• Ei, eu não perguntei qual usar!
  Ah, mas você realmente queria admitir.
• Então, quando devo usar ponteiros regulares?
  Principalmente no código alheio à propriedade da memória. Isso normalmente ocorre em funções que obtêm um ponteiro de outro lugar e não alocam nem desalocam, e não armazenam uma cópia do ponteiro que supera sua execução.

Ponteiro inteligente é um tipo de ponteiro com algumas funcionalidades adicionais, por exemplo, desalocação automática de memória, contagem de referência etc.

Pequena introdução está disponível na página Ponteiros inteligentes - O que, por quê, qual? .

Um dos tipos simples de ponteiro inteligente é std::auto_ptr(capítulo 20.4.5 do padrão C ++), que permite desalocar automaticamente a memória quando está fora do escopo e que é mais robusto do que o uso simples do ponteiro quando exceções são lançadas, embora menos flexíveis.

Outro tipo conveniente é o boost::shared_ptrque implementa a contagem de referências e desaloca automaticamente a memória quando nenhuma referência ao objeto permanece. Isso ajuda a evitar vazamentos de memória e é fácil de usar para implementar o RAII .

O assunto é abordado em profundidade no livro "C ++ Templates: The Complete Guide", de David Vandevoorde, Nicolai M. Josuttis , capítulo Capítulo 20. Ponteiros inteligentes. Alguns tópicos abordados:

• Protegendo contra exceções
• Holders, (note que std :: auto_ptr é a implementação desse tipo de ponteiro inteligente)
• A aquisição de recursos é inicializada (geralmente usada para gerenciamento de recursos seguros para exceções em C ++)
• Limitações do titular
• Contagem de referência
• Acesso ao contador simultâneo
• Destruição e desalocação

As definições fornecidas por Chris, Sergdev e Llyod estão corretas. No entanto, prefiro uma definição mais simples, apenas para manter minha vida simples: um ponteiro inteligente é simplesmente uma classe que sobrecarrega os operadores -> e *. O que significa que seu objeto se parece semanticamente com um ponteiro, mas você pode fazê-lo de maneira mais interessante, incluindo contagem de referências, destruição automática etc. shared_ptre auto_ptré suficiente na maioria dos casos, mas é fornecido com seu próprio conjunto de pequenas idiossincrasias.

Um ponteiro inteligente é como um ponteiro normal (digitado), como "char *", exceto quando o ponteiro em si fica fora do escopo, o que ele aponta também é excluído. Você pode usá-lo como faria com um ponteiro comum, usando "->", mas não se precisar de um ponteiro real para os dados. Para isso, você pode usar "& * ptr".

É útil para:

• Objetos que devem ser alocados com novos, mas que você gostaria de ter o mesmo tempo de vida útil de algo nessa pilha. Se o objeto estiver atribuído a um ponteiro inteligente, eles serão excluídos quando o programa sair dessa função / bloco.

• Membros de dados de classes, para que, quando o objeto for excluído, todos os dados pertencentes também sejam excluídos, sem nenhum código especial no destruidor (você precisará ter certeza de que o destruidor é virtual, o que é quase sempre uma boa coisa a fazer) .

Você pode não querer usar um ponteiro inteligente quando:

• ... o ponteiro não deve realmente possuir os dados ... ou seja, quando você está apenas usando os dados, mas deseja que ele sobreviva à função em que os está referenciando.
• ... o ponteiro inteligente não será destruído em algum momento. Você não deseja que ele fique na memória que nunca é destruída (como em um objeto que é alocado dinamicamente, mas não será excluído explicitamente).
• ... dois ponteiros inteligentes podem apontar para os mesmos dados. (No entanto, existem indicadores ainda mais inteligentes que lidarão com isso ... isso é chamado de contagem de referência .)

Veja também:

• coleta de lixo .
• Essa questão de estouro de pilha referente à propriedade dos dados

A maioria dos tipos de ponteiros inteligentes manipula o descarte do objeto ponteiro para você. É muito útil porque você não precisa mais pensar em descartar objetos manualmente.

Os ponteiros inteligentes mais usados ​​são std::tr1::shared_ptr(ou boost::shared_ptr) e, menos comumente std::auto_ptr,. Eu recomendo o uso regular de shared_ptr.

shared_ptré muito versátil e lida com uma grande variedade de cenários de descarte, incluindo casos em que os objetos precisam ser "passados ​​pelos limites da DLL" (o caso de pesadelo comum se diferentes libcs forem usados ​​entre o código e as DLLs).

Um ponteiro inteligente é um objeto que age como um ponteiro, mas também fornece controle sobre construção, destruição, cópia, movimentação e desreferenciação.

Pode-se implementar o seu próprio ponteiro inteligente, mas muitas bibliotecas também fornecem implementações de ponteiros inteligentes, cada uma com vantagens e desvantagens diferentes.

Por exemplo, o Boost fornece as seguintes implementações de ponteiros inteligentes:

• shared_ptr<T>é um ponteiro para o Tuso de uma contagem de referência para determinar quando o objeto não é mais necessário.
• scoped_ptr<T>é um ponteiro excluído automaticamente quando sai do escopo. Nenhuma atribuição é possível.
• intrusive_ptr<T>é outro ponteiro de contagem de referência. Ele fornece um desempenho melhor que shared_ptr, mas requer que o tipo Tforneça seu próprio mecanismo de contagem de referência.
• weak_ptr<T>é um ponteiro fraco, trabalhando em conjunto com shared_ptrpara evitar referências circulares.
• shared_array<T>é como shared_ptr, mas para matrizes de T.
• scoped_array<T>é como scoped_ptr, mas para matrizes de T.

Essas são apenas uma descrição linear de cada uma e podem ser usadas conforme a necessidade. Para obter mais detalhes e exemplos, consulte a documentação do Boost.

Além disso, a biblioteca padrão C ++ fornece três ponteiros inteligentes; std::unique_ptrpara propriedade exclusiva, std::shared_ptrpropriedade compartilhada e std::weak_ptr. std::auto_ptrexistia em C ++ 03, mas agora está obsoleta.

Aqui está o link para obter respostas semelhantes: http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

Um ponteiro inteligente é um objeto que age, parece e parece um ponteiro normal, mas oferece mais funcionalidade. No C ++, ponteiros inteligentes são implementados como classes de modelo que encapsulam um ponteiro e substituem os operadores de ponteiro padrão. Eles têm várias vantagens sobre ponteiros regulares. Eles são garantidos para serem inicializados como ponteiros nulos ou ponteiros para um objeto de heap. A indicação através de um ponteiro nulo é verificada. Nenhuma exclusão é necessária. Os objetos são liberados automaticamente quando o último ponteiro para eles desaparece. Um problema significativo com esses ponteiros inteligentes é que, diferentemente dos ponteiros regulares, eles não respeitam a herança. Ponteiros inteligentes não são atraentes para código polimórfico. Dado a seguir é um exemplo para a implementação de ponteiros inteligentes.

Exemplo:

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

Essa classe implementa um ponteiro inteligente para um objeto do tipo X. O próprio objeto está localizado no heap. Aqui está como usá-lo:

smart_pointer <employee> p= employee("Harris",1333);

Como outros operadores sobrecarregados, p se comportará como um ponteiro regular,

cout<<*p;
p->raise_salary(0.5);

http://en.wikipedia.org/wiki/Smart_pointer

Na ciência da computação, um ponteiro inteligente é um tipo de dados abstrato que simula um ponteiro e fornece recursos adicionais, como coleta automática de lixo ou verificação de limites. Esses recursos adicionais visam reduzir os erros causados ​​pelo uso indevido dos ponteiros, mantendo a eficiência. Os ponteiros inteligentes normalmente acompanham os objetos que apontam para eles para fins de gerenciamento de memória. O uso indevido de ponteiros é uma das principais fontes de erros: a alocação, desalocação e referência constantes que devem ser executadas por um programa escrito usando ponteiros tornam muito provável que ocorram vazamentos de memória. Ponteiros inteligentes tentam impedir vazamentos de memória, tornando a desalocação automática de recursos: quando o ponteiro de um objeto (ou o último de uma série de ponteiros) é destruído,

Seja T uma classe neste tutorial Os ponteiros em C ++ podem ser divididos em 3 tipos:

1) ponteiros brutos :

T a;  
T * _ptr = &a; 

Eles mantêm um endereço de memória em um local na memória. Use com cuidado, pois os programas se tornam complexos e difíceis de acompanhar.

Ponteiros com dados ou endereço const {Read backwards}

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

Ponteiro para um tipo de dados T que é uma const. Ou seja, você não pode alterar o tipo de dados usando o ponteiro. ie *ptr1 = 19; não funciona. Mas você pode mover o ponteiro. ie ptr1++ , ptr1--; etc vai funcionar. Leia para trás: ponteiro para o tipo T, que é const

  T * const ptr2 ;

Um ponteiro const para um tipo de dados T. Isso significa que você não pode mover o ponteiro, mas pode alterar o valor apontado pelo ponteiro. ou seja, *ptr2 = 19vai funcionar, mas ptr2++ ; ptr2--etc não vai funcionar. Ler para trás: ponteiro const para um tipo T

const T * const ptr3 ; 

Um ponteiro const para um tipo de dados const T. Ou seja, você não pode mover o ponteiro nem alterar o ponteiro do tipo de dados para ele. ie ptr3-- ; ptr3++ ; *ptr3 = 19;não funciona

3) ponteiros inteligentes : { #include <memory>}

Ponteiro compartilhado :

  T a ; 
     //shared_ptr<T> shptr(new T) ; not recommended but works 
     shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe

     std::cout << shptr.use_count() ; // 1 //  gives the number of " 
things " pointing to it. 
     T * temp = shptr.get(); // gives a pointer to object

     // shared_pointer used like a regular pointer to call member functions
      shptr->memFn();
     (*shptr).memFn(); 

    //
     shptr.reset() ; // frees the object pointed to be the ptr 
     shptr = nullptr ; // frees the object 
     shptr = make_shared<T>() ; // frees the original object and points to new object

Implementado usando a contagem de referência para acompanhar quantas "coisas" apontam para o objeto apontado pelo ponteiro. Quando essa contagem chega a 0, o objeto é excluído automaticamente, ou seja, o objeto é excluído quando todo o share_ptr que aponta para o objeto sai do escopo. Isso elimina a dor de cabeça de ter que excluir objetos que você alocou usando new.

Ponteiro fraco: ajuda a lidar com referências cíclicas que surgem ao usar o ponteiro compartilhado Se você tiver dois objetos apontados por dois ponteiros compartilhados e houver um ponteiro compartilhado interno apontando para o ponteiro compartilhado, haverá uma referência cíclica e o objeto não será ser excluído quando ponteiros compartilhados ficarem fora do escopo. Para resolver isso, altere o membro interno de shared_ptr para weak_ptr. Nota: Para acessar o elemento apontado por um ponteiro fraco, use lock (), isso retornará um valor_ptr.

T a ; 
shared_ptr<T> shr = make_shared<T>() ; 
weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr 
wk.lock()->memFn() ; // use lock to get a shared_ptr 
//   ^^^ Can lead to exception if the shared ptr has gone out of scope
if(!wk.expired()) wk.lock()->memFn() ;
// Check if shared ptr has gone out of scope before access

Veja: Quando std :: weak_ptr é útil?

Ponteiro exclusivo: ponteiro inteligente leve com propriedade exclusiva. Use quando o ponteiro aponta para objetos exclusivos sem compartilhar os objetos entre os ponteiros.

unique_ptr<T> uptr(new T);
uptr->memFn(); 

//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr
uptr.reset() ; // deletes the object pointed to by uptr 

Para alterar o objeto apontado pelo ptr exclusivo, use mover semântica

unique_ptr<T> uptr1(new T);
unique_ptr<T> uptr2(new T);
uptr2 = std::move(uptr1); 
// object pointed by uptr2 is deleted and 
// object pointed by uptr1 is pointed to by uptr2
// uptr1 becomes null 

Referências: Elas podem ser essencialmente consideradas ponteiros const, ou seja, um ponteiro que é const e não pode ser movido com melhor sintaxe.

Consulte: Quais são as diferenças entre uma variável de ponteiro e uma variável de referência em C ++?

r-value reference : reference to a temporary object   
l-value reference : reference to an object whose address can be obtained
const reference : reference to a data type which is const and cannot be modified 

Referência: https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ Agradecimentos a Andre por apontar esta pergunta.

Um ponteiro inteligente é uma classe, um invólucro de um ponteiro normal. Diferentemente dos ponteiros normais, o ciclo de vida do ponto inteligente é baseado em uma contagem de referência (quantas vezes o objeto do ponteiro inteligente é atribuído). Portanto, sempre que um ponteiro inteligente é atribuído a outro, a referência interna conta mais mais. E sempre que o objeto sai do escopo, a contagem de referência menos menos.

O ponteiro automático, embora parecido, é totalmente diferente do ponteiro inteligente. É uma classe conveniente que desaloca o recurso sempre que um objeto de ponteiro automático sai do escopo variável. Até certo ponto, faz um ponteiro (para memória alocada dinamicamente) funcionar de maneira semelhante a uma variável de pilha (alocada estaticamente no tempo de compilação).

Ponteiros inteligentes são aqueles em que você não precisa se preocupar com desalocação de memória, compartilhamento e transferência de recursos.

Você pode muito bem usar esse ponteiro da mesma maneira que qualquer alocação funciona em Java. No java, o Garbage Collector faz o truque, enquanto no Smart Pointers, o truque é feito pelos destruidores.

As respostas existentes são boas, mas não cobrem o que fazer quando um ponteiro inteligente não é a resposta (completa) para o problema que você está tentando resolver.

Entre outras coisas (explicadas bem em outras respostas), o uso de um ponteiro inteligente é uma solução possível para Como usamos uma classe abstrata como um tipo de retorno de função? que foi marcado como duplicado desta pergunta. No entanto, a primeira pergunta a perguntar se é tentado especificar uma classe base abstrata (ou de fato qualquer) como um tipo de retorno em C ++ é "o que você realmente quer dizer?". Há uma boa discussão (com referências adicionais) da programação orientada a objetos idiomáticos em C ++ (e como isso é diferente de outras linguagens) na documentação da biblioteca de contêiner de ponteiro de aumento. Em resumo, em C ++, você precisa pensar em propriedade. Quais indicadores inteligentes ajudam você, mas não são a única solução, ou sempre são uma solução completa (eles não oferecem cópia polimórfica) e nem sempre são uma solução que você deseja expor em sua interface (e o retorno de uma função parece horrível muito parecido com uma interface). Pode ser suficiente retornar uma referência, por exemplo. Mas em todos esses casos (ponteiro inteligente, contêiner de ponteiro ou simplesmente retornar uma referência), você alterou o retorno de um valor para alguma forma de referência . Se você realmente precisava copiar, pode ser necessário adicionar mais "idiomática" padrão ou ir além do OOP idiomático (ou não) no C ++ para um polimorfismo mais genérico usando bibliotecas como Adobe Poly ou Boost.TypeErasure.