Classe shared_ptr
Envolve um ponteiro inteligente de contagem em torno de um objeto dinamicamente atribuído.
template<class Ty>
class shared_ptr {
public:
typedef Ty element_type;
shared_ptr();
shared_ptr(nullptr_t);
shared_ptr(const shared_ptr& sp);
shared_ptr(shared_ptr&& sp);
template<class Other>
explicit shared_ptr(Other * ptr);
template<class Other, class D>
shared_ptr(Other * ptr, D dtor);
template<class D>
shared_ptr(nullptr_t, D dtor);
template<class Other, class D, class A>
shared_ptr(Other *ptr, D dtor, A alloc);
template<class D, class A>
shared_ptr(nullptr_t, D dtor, A alloc);
template<class Other>
shared_ptr(const shared_ptr<Other>& sp);
template<class Other>
shared_ptr(const shared_ptr<Other>&& sp);
template<class Other>
explicit shared_ptr(const weak_ptr<Other>& wp);
template<class Other>
shared_ptr(auto_ptr<Other>& ap);
template<class Other, class D>
shared_ptr(unique_ptr<Other, D>&& up);
template<class Other>
shared_ptr(const shared_ptr<Other>& sp, Ty *ptr);
~shared_ptr();
shared_ptr& operator=(const shared_ptr& sp);
template<class Other>
shared_ptr& operator=(const shared_ptr<Other>& sp);
shared_ptr& operator=(shared_ptr&& sp);
template<class Other>
shared_ptr& operator=(shared_ptr<Other>&& sp);
template<class Other>
shared_ptr& operator=(auto_ptr< Other >&& ap);
template <class Other, class D>
shared_ptr& operator=(const unique_ptr< Other, D>& up) = delete;
template <class Other, class D>
shared_ptr& operator=(unique_ptr<Other, D>&& up);
void swap(shared_ptr& sp);
void reset();
template<class Other>
void reset(Other *ptr);
template<class Other, class D>
void reset(Other *ptr, D dtor);
template<class Other, class D, class A>
void reset(Other *ptr, D dtor, A alloc);
Ty *get() const;
Ty& operator*() const;
Ty *operator->() const;
long use_count() const;
bool unique() const;
operator bool() const;
template<class Other>
bool owner_before(shared_ptr<Other> const& ptr) const;
template<class Other>
bool owner_before(weak_ptr<Other> const& ptr) const;
template<class D, class Ty>
D* get_deleter(shared_ptr<Ty> const& ptr);
};
Parâmetros
Ty
O tipo controlado pelo ponteiro compartilhado.Other
O tipo controlado pelo ponteiro do argumento.ptr
O ponteiro a ser copiado.D
O tipo de deletor.A
O tipo de alocador.dtor
O deletor.alloc
O alocador.sp
O ponteiro inteligente a ser copiado ou movido.wp
O ponteiro fraco a ser copiado ou movido.ap
O ponteiro automático a ser copiado ou movido.up
O ponteiro exclusivo a ser movido.
Comentários
A classe de modelo descreve um objeto que usa contagem de referência para gerenciar recursos. Um objeto shared_ptr contém efetivamente um ponteiro para o recurso que possui ou contém um ponteiro nulo. Um recurso pode ser possuído por mais de um objeto shared_ptr ; quando o último objeto shared_ptr que possui um recurso específico é destruído, o recurso é liberado.
Um shared_ptr deixa de possuir um recurso quando é reatribuído ou redefinido.
O argumento de modelo Ty pode ser um tipo incompleto, exceto conforme observado para determinadas funções membro.
Quando um objeto shared_ptr<Ty> é construído a partir de um ponteiro de recurso do tipo G* ou de um shared_ptr<G>, o tipo de ponteiro G* deve ser possível de converter em Ty*. Se não estiver, o código não será compilado. Por exemplo:
class F {};
class G : public F {};
#include <memory>
using namespace std;
shared_ptr<G> sp0(new G); // okay, template parameter G and argument G*
shared_ptr<G> sp1(sp0); // okay, template parameter G and argument shared_ptr<G>
shared_ptr<F> sp2(new G); // okay, G* convertible to F*
shared_ptr<F> sp3(sp0); // okay, template parameter F and argument shared_ptr<G>
shared_ptr<F> sp4(sp2); // okay, template parameter F and argument shared_ptr<F>
shared_ptr<int> sp5(new G); // error, G* not convertible to int*
shared_ptr<int> sp6(sp2); // error, template parameter int and argument shared_ptr<F>
Um objeto shared_ptr possui um recurso:
se foi construído com um ponteiro para esse recurso,
se foi construído a partir de um objeto de shared_ptr que possua esse recurso,
se foi construído a partir de um objeto de Classe weak_ptr que aponta para esse recurso, ou
se a propriedade do recurso tiver sido atribuída, com shared_ptr::operator= ou chamando a função de membro shared_ptr::reset.
Os objetos shared_ptr que possuem um recurso compartilham um bloco de controle. O bloco de controle contém:
o número de objetos shared_ptr que possuem o recurso,
o número de objetos weak_ptr que apontam para o recurso,
o deletor para esse recurso se houver um,
o alocador personalizado para o bloco de controle, se houver um.
Um objeto shared_ptr que é inicializado com um ponteiro nulo que tem um bloco de controle e não está vazio. Depois que um objeto shared_ptr libera um recurso, ele não possui mais esse recurso. Depois que um objeto weak_ptr libera um recurso, ele não possui mais esse recurso.
Quando o número de objetos shared_ptr que possuem um recurso se torna zero, o recurso é liberado excluindo-o ou passando o endereço dele a um excluidor, dependendo de como a propriedade do recurso foi originalmente criada. Quando o número de objetos shared_ptr que possuem um recurso é zero e o número de objetos weak_ptr que apontam para esse recurso é zero, o bloco de controle é liberado usando o alocador personalizado do bloco de controle, se houver.
Um objeto vazio shared_ptr não possui recursos e nem tem nenhum bloco de controle em si.
Um deletor é um objeto de função com uma função de membro operator(). Seu tipo deve ser cópia construtível, e seu construtor e destruidor de cópia não devem lançar exceções. Aceita um parâmetro, o objeto a ser excluído.
Algumas funções usam uma lista de argumentos que define propriedades do objeto shared_ptr<Ty> ou weak_ptr<Ty> resultante. Você pode especificar uma lista de argumentos de várias maneiras:
nenhum argumento -- o objeto resultante é um objeto vazio de shared_ptr ou um objeto vazio de weak_ptr.
ptr -- um ponteiro de tipo Other* para o recurso a ser gerenciado. Ty deve ser um tipo completo. Se a função falhar (em decorrência do bloco de controle não poder ser atribuído), avalia a expressão delete ptr.
ptr, dtor -- um ponteiro de tipo Other* para o recurso a ser gerenciado e um deletor para esse recurso. Se a função falhar (em decorrência do bloco de controle não poder ser atribuído), chama dtor(ptr), que deve ser bem definido.
ptr, dtor, alloc -- um ponteiro de tipo Other* para o recurso a ser gerenciado, um deletor para esse recurso e um alocador para gerenciar qualquer armazenamento que deva ser alocado e liberado. Se a função falhar (em decorrência do bloco de controle não poder ser atribuído), chama dtor(ptr), que deve ser bem definido.
sp -- um objeto shared_ptr<Other> que possui o recurso a ser gerenciado.
wp -- um objeto weak_ptr<Other> que aponta para o recurso a ser gerenciado.
ap -- um objeto auto_ptr<Other> que contém um ponteiro para o recurso a ser gerenciado. Se a função tiver êxito, chama; ap.release(); caso contrário, deixa ap inalterado.
Em todos os casos, o tipo de ponteiro Other* deve ser conversível para Ty*.
Acesso thread-safe
Vários segmentos podem ler e gravar diferentes objetos de shared_ptr ao mesmo tempo, mesmo quando os objetos forem cópias que compartilham a propriedade.
Membros
Construtores
Constrói um shared_ptr. |
|
Destrói um shared_ptr. |
Métodos
O tipo de um elemento. |
|
Obtém o endereço do recurso de propriedade. |
|
Retorna true se este shared_ptr for ordenado antes (ou for menor que) o ponteiro fornecido. |
|
Substitua o recurso de propriedade. |
|
Alterna dois objetos shared_ptr. |
|
Testa se um recurso propriedade é exclusivo. |
|
Conta o número de proprietários de recurso. |
Operadores
Testa se um recurso de propriedade existe. |
|
Obtém o valor designado. |
|
Substitui o recurso de propriedade. |
|
Obtém um ponteiro para o valor designado. |
Requisitos
Cabeçalho: <memória>
Namespace: std
Consulte também
Referência
Segurança de threads na Biblioteca Padrão C++