shared_ptr Class
Envolve um ponteiro inteligente da contagem em torno de um objeto atribuído dinamicamente.
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 para copiar.D
O tipo de deleter.A
O tipo do distribuidor.dtor
O deleter.alloc
O distribuidor.sp
O ponteiro inteligente para copiar ou mover.wp
O ponteiro fraco para copiar ou mover.ap
O ponteiro automático para copiar ou mover.up
O ponteiro exclusivo para mover.
Comentários
A classe de modelo descreve um objeto que usa referenciam a contagem para gerenciar recursos.Um objeto de shared_ptr efetivamente contém um ponteiro para o recurso que possui ou contém um ponteiro nulo.Um recurso pode ser possuído por mais de um objeto de shared_ptr ; quando o objeto mais recente de shared_ptr que possui um recurso específico é destruído, o recurso é liberado.
Para shared_ptr de possuir um recurso quando é reatribuido ou redefinido.
O argumento Ty de modelo pode ser funções de membro incompletas de um tipo exceto mencione em contraste com certeza.
Quando um objeto de shared_ptr<Ty> é construído de um ponteiro de recurso do tipo G* ou de shared_ptr<G>, o tipo G* ponteiro deve ser conversível a Ty*.Se não estiver, o código não será compilado.Por exemplo:
class F {};
class G : public F {};
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> sp4(new G); // error, G* not convertible to int*
shared_ptr<int> sp5(sp2); // error, template parameter int and argument shared_ptr<F>
Um objeto de shared_ptr possui um recurso:
se foi construído com um ponteiro para esse recurso,
se foi construído de um objeto de shared_ptr que possua esse recurso,
se foi construído de um objeto de weak_ptr Class que aponta para esse recurso, ou
se a propriedade do recurso ele foi atribuído, com shared_ptr::operator= ou chamar a função de membro shared_ptr::reset.
shared_ptr objetos que possua um compartilhamento de recursos um bloco de controle.As mantém do bloco de controle:
o número de shared_ptr objetos que possua o recurso,
o número de objetos weak_ptr esse ponto, o recurso
o deleter para esse recurso, se um tiver
o distribuidor personalizado para o bloco de controle se houver.
Um objeto de shared_ptr que é inicializada usando um ponteiro zero tem um bloco de controle e não está vazia.Depois que um objeto de shared_ptr libera um recurso, não possui esse recurso.Depois que um objeto de weak_ptr libera um recurso, ele não aponta para o recurso.
Quando o número de shared_ptr objetos que possua um recurso se torna zero, o recurso é solto, ou deletando o ou passando o endereço a um deleter, dependendo de como a propriedade de recurso foi originalmente criado.Quando o número de shared_ptr objeto que possua um recurso é zero, e o número de weak_ptr objetos que aponte para esse recurso é zero, o bloco de controle é solto, usando o distribuidor personalizado para o bloco de controle se houver.
Um objeto vazio de shared_ptr não possui nenhum recursos e não tem nenhum bloco de controle.
Um deleter é um objeto de função que tem uma função de membro operator().Seu tipo deve ser construtível impressão, e seus construtor e destrutor de impressão não devem lançar exceções.Aceita um parâmetro, o objeto a ser excluído.
Algumas funções têm uma lista de argumentos que define propriedades de shared_ptr<Ty> ou do objeto resultante de weak_ptr<Ty> .Você pode especificar a lista de argumentos em várias maneiras:
quaisquer argumentos -- o objeto resultante é um objeto vazio de shared_ptr ou um objeto vazio de weak_ptr .
ptr -- um ponteiro de tipo Other* ao recurso seja gerenciado.Ty deve ser um tipo completo.Se a função (falha porque o bloco de controle não pode ser atribuído) avalia a expressão delete ptr.
ptr, dtor -- um ponteiro de tipo Other* ao recurso seja gerenciado e um deleter para esse recurso.Se a função (falha porque o bloco de controle não pode ser atribuído), chama dtor(ptr), que devem ser bem definido.
ptr, dtor, alloc -- um ponteiro de tipo Other* ao recurso seja gerenciado, um deleter para esse recurso, e um distribuidor para gerenciar qualquer armazenamento que devem ser atribuído e solto.Se a função (falha porque o bloco de controle não pode ser atribuído) chama dtor(ptr), que devem ser bem definido.
sp -- um objeto de shared_ptr<Other> que possua o recurso seja gerenciado.
wp -- um objeto de weak_ptr<Other> que aponta para o recurso seja gerenciado.
ap -- um objeto de auto_ptr<Other> que contém um ponteiro para o recurso seja gerenciado.Se chama a função êxito; ap.release()se não permite ap inalterado.
Em todos os casos, o tipo Other* ponteiro deve ser conversível a Ty*.
Segurança de Segmentos
Vários segmentos podem ler e gravar shared_ptr diferente objetos ao mesmo tempo, mesmo quando os objetos são as cópias que compartilham a propriedade.
Membros
.gif "Bb982026.collapse_all(pt-br,VS.110).gif")
Construtores
Constrói shared_ptr. |
|
For shared_ptr. |
Métodos
O tipo de um elemento. |
|
Obtém o endereço de recurso propriedade. |
|
Retorna true se este shared_ptr é ordenada antes (ou menor que) do ponteiro fornecido. |
|
Replace propriedade do recurso. |
|
Troca dois objetos de shared_ptr . |
|
Teste se o recurso propriedade é exclusivo. |
|
Números de resultados de proprietários de recurso. |
Operadores
Teste se um recurso propriedade existe. |
|
Obtém o valor designado. |
|
Substitui o recurso propriedade. |
|
Obtém um ponteiro para o valor designado. |
Requisitos
Cabeçalho: <memory>
Namespace: STD
Consulte também
Referência
Segurança do thread na biblioteca C++ padrão