std::shared_ptr::shared_ptr

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

Biblioteca de utilitários

Digite apoio (basic types, RTTI, type traits)

Gerenciamento de memória dinâmica

De tratamento de erros

Utilidades do programa

(C++11)

(C++11)

Os operadores relacionais

rel_ops::operator!=
rel_ops::operator>
rel_ops::operator<=
rel_ops::operator>=

Pares e tuplas

pair

tuple

(C++11)

piecewise_construct_t

(C++11)

piecewise_construct

(C++11)

Troque, avançar e avançar

(C++11)

(C++11)

(C++11)

(C++11)

Gerenciamento de memória dinâmica

Gerenciamento de memória de baixo nível

Alocadores

(C++11)

(C++11)

(C++11)

(C++11)

scoped_allocator_adaptor

(C++11)

Uninitialized armazenamento

(C++11)

return_temporary_buffer

Ponteiros inteligentes

(C++11)

(C++11)

(C++11)

(obsoleta)

(C++11)

enable_shared_from_this

(C++11)

bad_weak_ptr

(C++11)

default_delete

(C++11)

Apoio a coleta de lixo

declare_reachable

(C++11)

undeclare_reachable

(C++11)

declare_no_pointers

(C++11)

undeclare_no_pointers

(C++11)

pointer_safety

(C++11)

get_pointer_safety

(C++11)

Diversos

pointer_traits

(C++11)

addressof

(C++11)

align

(C++11)

C Library

malloc
calloc

realloc
free

[edit]

std::shared_ptr

Funções de membro

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Modificadores

shared_ptr::reset

shared_ptr::swap

Observadores

shared_ptr::get

shared_ptr::operator*
shared_ptr::operator->

shared_ptr::use_count

shared_ptr::unique

shared_ptr::operator bool

shared_ptr::owner_before

Não-membros funções

std::swap

make_shared

allocate_shared

static_pointer_castdynamic_pointer_castconst_pointer_cast

get_deleter

operator==operator|=operator<operator<=operator>operator>=

operator<<

atomic_is_lock_freeatomic_loadatomic_load_explicitatomic_storeatomic_store_explicitatomic_exchangeatomic_exchange_explicitatomic_compare_exchange_weakatomic_compare_exchange_strongatomic_compare_exchange_weak_explicitatomic_compare_exchange_strong_explicit

std::hash

[edit]


`constexpr shared_ptr();`	(1)

`template< class Y > explicit shared_ptr( Y* ptr );`	(2)

`template< class Y, class Deleter > shared_ptr( Y* ptr, Deleter d );`	(3)

`template< class Y, class Deleter, class Alloc > shared_ptr( Y* ptr, Deleter d, Alloc alloc );`	(4)

`constexpr shared_ptr( std::nullptr_t );`	(5)

`template< class Deleter > shared_ptr( std::nullptr_t, Deleter d );`	(6)

`template< class Deleter, class Alloc > shared_ptr( std::nullptr_t, Deleter d, Alloc alloc );`	(7)

`template< class Y > shared_ptr( const shared_ptr<Y>& r, T *ptr );`	(8)

`shared_ptr( const shared_ptr& r );`	(9)

`template< class Y > shared_ptr( const shared_ptr<Y>& r );`	(9)

`shared_ptr( shared_ptr&& r );`	(10)

`template< class Y > shared_ptr( shared_ptr<Y>&& r );`	(10)

`template< class Y > explicit shared_ptr( const std::weak_ptr<Y>& r );`	(11)

`template< class Y > shared_ptr( std::auto_ptr<Y>&& r );`	(12)

`template< class Y, class Deleter > shared_ptr( std::unique_ptr<Y,Deleter>&& r );`	(13)

Constrói shared_ptr novo a partir de uma variedade de tipos de ponteiro que se referem a um objecto de gerir. Opcional deleter d pode ser fornecido, que é depois usado para destruir o objeto quando não há objetos shared_ptr ele próprio. Por padrão, a expressão é usada como excluir expressão deleter. delete expressão adequada correspondente ao tipo fornecido é sempre selecionada, essa é a razão pela qual os construtores são implementados como modelos usando um Y parâmetro separado.

Se o objeto apontado por ptr já pertence a algum ponteiro compartilhada, os resultados do construtor em um comportamento indefinido.

1)

Construtor padrão constrói uma shared_ptr sem objeto gerenciado, ou seja shared_ptr vazio

2-4)

Constrói um shared_ptr com ptr como objeto gerenciado. Y deve ser um tipo completo e implicitamente conversível para T. Além disso:

2)

Usa a expressão excluir como deleter. Uma expressão de exclusão válido deve estar disponível, ou seja, delete ptr deve ser bem formado, ter um comportamento bem definido e não lançar quaisquer exceções.

3)

Usa o d deleter especificado como o deleter. Deleter deve ser exigível para o tipo T, ou seja d(ptr) deve ser bem formado, ter um comportamento bem definido e não lançar quaisquer exceções. Deleter deve ser CopyConstructible.

4)

O mesmo que (3), mas adicionalmente, usa uma cópia de alloc para a atribuição de dados para uso interno. Alloc deve ser um Allocator. O construtor de cópia e destruidor não deve lançar exceções.

5-7)

Análoga a (2), (3), (4), respectivamente, mas constrói uma shared_ptr sem objecto gerido, ie vazio shared_ptr.

8)

Constrói um shared_ptr que compartilha informações de propriedade com r, mas tem um ptr ponteiro alheios e não gerenciados. Mesmo se este shared_ptr é o último do grupo a sair do escopo, ele irá chamar o destruidor do objeto originalmente gerida por r. No entanto, chamar get() sobre este irá sempre retornar uma cópia do ptr. É responsabilidade do programador para garantir que este ptr permanece válido, desde que este shared_ptr existe, como nos casos de uso típicos onde ptr é um membro do objeto gerenciado por r ou é um apelido (por exemplo, abatido) de r.get()

9)

Constrói um shared_ptr que compartilha a propriedade do objeto gerenciado pelo r. Se r gere nenhum objeto, *this gere nenhum objeto também. A sobrecarga de modelo não participar na resolução de sobrecarga se Y* não é implicitamente conversível para T*.

10)

Move-constrói uma shared_ptr de r. Após a construção, *this contém uma cópia do estado anterior do r, r está vazio. A sobrecarga de modelo não participar na resolução de sobrecarga se Y* não é implicitamente conversível para T*.

11)

Constrói um shared_ptr que compartilha a propriedade do objeto gerenciado pelo r. Y* deve ser conversível T*. Note-se que r.lock() podem ser utilizados para o mesmo fim: a diferença é que este construtor gera uma exceção se o argumento estiver vazia, enquanto std::weak_ptr<T>::lock() constrói uma std::shared_ptr vazio nesse caso.

12)

Constrói um shared_ptr que armazena e possui o objeto anteriormente detida pela r. Y* deve ser conversível T*. Após a construção, r está vazia.

13)

Constrói um shared_ptr que gerencia o objeto atualmente gerenciado por r. O deleter associado a r é armazenado para exclusão futuro do objeto gerenciado. r gere nenhum objeto após a chamada. Y* deve ser conversível T*.

Notas

Ao construir a partir de um ponteiro-prima para um objeto de um tipo derivado de std::enable_shared_from_this, os construtores de shared_ptr detectar outros proprietários do objeto através da referência fraca armazenado nessa classe base acionária e com eles, em vez de assumir que o objeto não é gerenciado.

Parâmetros

ptr	-	um apontador para um objecto de gerir Original: a pointer to an object to manage The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
d	-	uma deleter usar para destruir o objeto Original: a deleter to use to destroy the object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
alloc	-	um alocador de usar para alocações de dados para uso interno Original: an allocator to use for allocations of data for internal use The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
r	-	outro ponteiro inteligente de compartilhar a posse ou aquisição da propriedade de Original: another smart pointer to share the ownership to or acquire the ownership from The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Exceções

1)

noexcept specification:


`noexcept`

(desde C++11)

2)

std::bad_alloc se a memória adicional exigida não poderia ser obtida. Pode lançar implementação exceção definida para outros erros. delete ptr é chamado se ocorrer uma exceção.

3-4)

std::bad_alloc se a memória adicional exigida não poderia ser obtida. Pode lançar implementação exceção definida para outros erros. d(ptr) é chamado se ocorrer uma exceção.

5)

noexcept specification:


`noexcept`

(desde C++11)

6-7)

std::bad_alloc se a memória adicional exigida não poderia ser obtida. Pode lançar implementação exceção definida para outros erros. Se uma exceção é lançada, d(ptr) é executado.

8-10)

noexcept specification:


`noexcept`

(desde C++11)

11)

std::bad_weak_ptr se r.expired == true. O construtor não tem nenhum efeito neste caso.

12)

std::bad_alloc se a memória adicional exigida não poderia ser obtida. Pode lançar implementação exceção definida para outros erros. Esse construtor não tem efeito se ocorrer uma exceção.

13)

Se uma exceção é lançada, o construtor não tem efeitos.

Exemplo

#include <memory>
#include <iostream>

struct Foo {
    Foo() { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n"; }
};

struct D { 
    void operator()(Foo* p) const {
        std::cout << "Call delete for Foo object...\n";
        delete p;
    }
};

int main()
{	
    // constructor with no managed object
    std::shared_ptr<Foo> sh1;

    // constructor with object
    std::shared_ptr<Foo> sh2(new Foo);
    std::shared_ptr<Foo> sh3(sh2);
    std::cout << sh2.use_count() << '\n';
    std::cout << sh3.use_count() << '\n';

    //constructor with object and deleter
    std::shared_ptr<Foo> sh4(new Foo, D());
}

Saída:

Foo...
2
2
Foo...
Call delete for Foo object...
~Foo...
~Foo...

Veja também


make_shared	cria um ponteiro comum que gere um novo objeto Original: creates a shared pointer that manages a new object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]

allocate_shared	cria um ponteiro comum que gere um novo objeto alocado utilizando um alocador Original: creates a shared pointer that manages a new object allocated using an allocator The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (modelo de função) [edit]

Suporte ao Compilador
Freestanding and hosted
Linguagem
Headers da Biblioteca Standard
Requerimentos nomeados
Feature test macros (C++20)
Biblioteca de suporte de língua
Biblioteca de conceitos (C++20)
Biblioteca de diagnósticos
Biblioteca de utilitários em geral
Biblioteca de strings
Biblioteca de containers
Ranges library (C++20)
Biblioteca de iteradores
Biblioteca de algorítmos
Biblioteca numérica
Biblioteca de localizações
Biblioteca de input/output
Biblioteca de sistema de arquivo (C++17)
Biblioteca de expressões regulares (C++11)
Biblioteca de operações atômicas (C++11)
Biblioteca de suporte de thread (C++11)
Especificações Técnicas
Índice de symbolos
Bibliotecas externas

cppreference.com

Procurar

Espaços nominais

Variantes

Visualizações

Ações

std::shared_ptr::shared_ptr

Índice

Notas

Parâmetros

Exceções

Exemplo

Veja também

Navegação

Ferramentas