Classe shared_ptr
Quebra um ponteiro compartilhável.
template<class Ty>
class shared_ptr {
public:
typedef Ty element_type;
shared_ptr();
template<class Other>
explicit shared_ptr(Other*);
template<class Other, class D>
shared_ptr(Other*, D);
template<class Other, class D, class A>
shared_ptr(Other *ptr, D dtor, A ator);
shared_ptr(const shared_ptr&);
template<class Other>
shared_ptr(const shared_ptr<Other>&);
template<class Other>
shared_ptr(const weak_ptr<Other>&);
template<class &>
shared_ptr(const std::auto_ptr<Other>&);
~shared_ptr();
shared_ptr& operator=(const shared_ptr&);
template<class Other>
shared_ptr& operator=(const shared_ptr<Other>&);
template<class Other>
shared_ptr& operator=(auto_ptr<Other>&);
void swap(shared_ptr&);
void reset();
template<class Other>
void reset(Other*);
template<class Other, class D>
void reset(Other*, D);
Ty *get() const;
Ty& operator*() const;
Ty *operator->() const;
long use_count() const;
bool unique() const;
operator boolean-type() const;
};
Parâmetros
- Ty
O tipo controlado pelo ponteiro compartilhado.
Comentários
A classe de modelo descreve um objeto que usa a contagem gerenciar recursos de referência.Cada shared_ptr objeto efetivamente contém um ponteiro para o recurso que ele é proprietário ou contém um ponteiro nulo. Um recurso pode pertencer a mais de um shared_ptr objeto; quando o último shared_ptr objeto que possui um recurso em particular é destruído o recurso é liberado.
O argumento de modelo Ty pode ser um tipo incompleto, exceto conforme observado para determinadas seqüências operando.
Quando um shared_ptr<Ty> objeto é construído a partir de um ponteiro de recurso do tipo D* ou a partir de um shared_ptr<D>, o tipo de ponteiro D* deve ser conversível em Ty*. Se não estiver, o código não será compilado.Por exemplo:
class B {};
class D : public B {};
shared_ptr<D> sp0(new D); // okay, template parameter D and argument D*
shared_ptr<D> sp1(sp0); // okay, template parameter D and argument shared_ptr<D>
shared_ptr<B> sp2(new D); // okay, D* convertible to B*
shared_ptr<B> sp3(sp0); // okay, template parameter B and argument shared_ptr<D>
shared_ptr<B> sp4(sp2); // okay, template parameter B and argument shared_ptr<B>
shared_ptr<int> sp4(new D); // error, D* not convertible to int*
shared_ptr<int> sp5(sp2); // error, template parameter int and argument shared_ptr<B>
A shared_ptr objeto possui um recurso:
Se ele foi construído com um ponteiro para esse recurso
Se ele foi construído a partir de um shared_ptr objeto que possui esse recurso
Se ele foi construído a partir de um Classe weak_ptr objeto que aponta para esse recurso, ou
Se propriedade do recurso atribuída a ele, com shared_ptr::operador = ou ligando para a função de membro shared_ptr::reiniciar.
Todos os shared_ptr objetos que possuem um único recurso compartilham um bloco de controle que contém o número de shared_ptr objetos que possuem o recurso, o número de weak_ptr objetos que apontam para o recurso e deleter para esse recurso se ele tiver uma. A shared_ptr objeto que foi inicializado com um ponteiro nulo tem um bloco de controle, portanto não é um vazio shared_ptr. Após um shared_ptr objeto libera um recurso não é proprietário desse recurso. Após um weak_ptr objeto libera um recurso que ele não aponta mais para esse recurso. Quando o número de shared_ptr objetos que possuem um recurso é reduzido a zero o recurso é liberado, excluindo-o ou passando seu endereço para um deleter, dependendo de como propriedade de recurso foi originalmente criada. Quando o número de shared_ptr objetos que possuem um recurso é zero e o número de weak_ptr objetos que apontam para esse recurso é zero, o bloco de controle é liberado.
Um objeto shared_ptr vazio não possui todos os recursos e não possui nenhum bloco de controle.
Um deleter é um ponteiro de função ou um objeto de um tipo com uma função de membro operator(). Seu tipo deve ser construível cópia e seu construtor de cópia e destruidor não deve lançar exceções.Um deleter está limite a um shared_ptr objeto com uma sequência de operando de forma ptr, dtor.
Algumas funções sejam uma sequência de operando que define propriedades do resultante shared_ptr<Ty> ou weak_ptr<Ty> objeto. Você pode especificar como uma sequência de operando várias maneiras:
Nenhum argumento--o objeto resultante é um objeto shared_ptr vazio ou um objeto weak_ptr vazio.
ptr --um ponteiro de tipo Other* para o recurso a fim de serem gerenciado. Ty deve ser um tipo de total. Se a função falhar, ele avalia a expressão delete ptr.
ptr, dtor --um ponteiro de tipo Other* para o recurso a ser gerenciado e um deleter desse recurso. Se a função falhar, ele chama dtor(ptr), que deve ser bem definidos.
sp --um shared_ptr<Other> objeto que possui o recurso a ser gerenciado.
wp --um weak_ptr<Other> objeto que aponta para o recurso a ser gerenciado.
ap --um auto_ptr<Other> objeto que contém um ponteiro para o recurso a ser gerenciado. Se a função obtiver êxito chama ap.release(); Caso contrário, ele deixa ap inalterado.
Em todos os casos, o ponteiro digite Other* deve ser conversível em Ty*.
Acesso thread-safe
Vários threads simultaneamente podem ler e gravar outro shared_ptr objetos, mesmo quando os objetos são cópias que compartilham a propriedade.
Requisitos
Cabeçalho:<memória>
Namespace: std::tr1