shared_ptr: o que é que usado para

Question

Eu faço um monte de uso de boost :: scoped_ptr no meu código e é ótimo, mas eu estou trabalhando atualmente com software que usa shared_ptr em todo o lugar e eu estou querendo saber se eu estou faltando alguma coisa.

AFAIK um shared_ptr só é útil se diferentes tópicos vão estar acessando os mesmos dados e você não sabe que ordem os tópicos estão indo para acabamento (com o shared_ptr garantindo que o objeto existe até o último discussão terminou com -lo).

Existem outros casos de uso?

Answer 1

Threads são irrelevantes aqui. O que é relevante é se é fácil de especificar um ponto em que o objeto não de uso é.

Suponha que vários objetos diferentes quiser usar o mesmo objeto. Pode ser um pacote de dados, ou para entrada / saída, ou algum objeto geométrico, ou o que quer. Você quer que o objeto compartilhado a ser eliminado depois de todos os que utilizam objetos são excluídos, e não um ciclo de relógio antes. Ao invés de descobrir que possuir objeto vai ter o tempo de vida mais longo (e que pode mudar se você alterar o programa, ou talvez através de interação com o usuário), você pode usar um shared_ptr para forçar esse comportamento.

Não importa se os que utilizam objetos estão na mesma ou em diferentes threads. Os objetos podem ter vidas imprevisíveis, mesmo se eles estão todos no mesmo segmento.

Answer 2

AFAIK um shared_ptr só é útil se diferentes tópicos vão ser acessando os mesmos dados

Bem, é para situações onde vários proprietários possuem o mesmo objeto apontado pelo ponteiro inteligente. Eles podem acessar os ponteiros inteligentes de diferentes segmentos, e shared_ptr é utilizável nessa área também, mas isso não é o ponto principal. Se o último proprietário perde sua referência ao objeto apontado, o mecanismo shared_ptr exclui o objeto.

Você pode usar um scoped_ptr se tudo que você quer é ter um ponteiro que é excluído quando o escopo é criado em resta (ou por exceções, por um Goto para um local fora, ou por fluxo de controlo normal ou de algum outro mecanismo). Se você usá-lo assim, não há necessidade de mudar para shared_ptr.

Answer 3

A diferença entre scoped_ptr e shared_ptr (e auto_ptr) é copiar principalmente semântica.

• scoped_ptr é para "Alocação recurso é inicialização " e não é copiável (que não pode ser compartilhado com outras instâncias e propriedade não pode ser transferida)
• shared_ptr é para recuperação automática de memória quando compartilhada entre várias partes
• auto_ptr é copiável (e transfere a propriedade quando atribuído)

Answer 4

Outra diferença importante entre shared_ptr e scoped_ptr é que só o trabalho shared_ptr com weak_ptr. ponteiros fracos são usadas para quebrar os ciclos de ponteiros compartilhados, evitando assim perdas de memória, mas weak_ptr pode ser usado para mais do que isso.

Shared e ponteiros fracos podem ser usados ??para expressar a diferença entre possuir e referências não possuir. propriedade inequívoca de ligações de dados para um design mais limpo, por isso, quando possíveis objetos de dados deve ser de propriedade de um outro objeto através de um shared_ptr. Todas as outras referências de vida longa a objetos de dados deve ser ponteiros fracos, expressando a sua não-propriedade dos dados. Cada vez que os módulos não possuem acessar os dados, eles precisam converter o weak_ptr em um shared_ptr, em que ponto eles podem achar que o objeto de dados não existe mais. No entanto, enquanto os módulos não possuir acessar o objeto de dados, eles segurá-la através shared_ptr transitória, garantindo uma operação segura, mesmo se o objeto possuir estavam a lançar os dados.

Answer 5

Como já respondeu, shared_ptr é sobre propriedade compartilhada. No entanto, eu diria que a propriedade compartilhada é geralmente uma coisa ruim (exceções existe, como FLYWEIGHT) e é melhor para identificar um proprietário e colocar um scoped_ptr lá.

Answer 6

A shared_ptr é um tipo de ponteiro inteligente que faz contagem de referência. Se há apenas um proprietário para o objeto (caso frequente), então scoped_ptr é a solução certa. Se o objeto pode ser compartilhado entre vários partes do código, então shared_ptr não vai deixar o objeto ser destruído até que todas as referências a ele foram liberados.