std::unique_ptr::unique_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 :: unique_ptr

Funções de membro

unique_ptr::unique_ptr

unique_ptr::~unique_ptr

unique_ptr::operator=

Modificadores

Observadores

unique_ptr::get_deleter

unique_ptr::operator bool

unique_ptr::operator*
unique_ptr::operator->

unique_ptr::operator[]

Não-membros funções

operator==operator!=operator<operator>operator<=operator>operator>=

std::swap

std::hash

[edit]


`constexpr unique_ptr();`	(1)	(desde C++11)

`explicit unique_ptr( pointer p );`	(2)	(desde C++11)

`unique_ptr( pointer p, d1 );`	(3)	(desde C++11)

`unique_ptr( pointer p, d2 );`	(4)	(desde C++11)

`unique_ptr( unique_ptr&& u );`	(5)	(desde C++11)

`constexpr unique_ptr( nullptr_t );`	(6)	(desde C++11)

`template< class U, class E > unique_ptr( unique_ptr<U, E>&& u );`	(7)	(desde C++11)

`template< class U > unique_ptr( auto_ptr<U>&& u );`	(8)	(desde C++11)

1)

Constrói um std::unique_ptr vazio.

2)

Constrói um std::unique_ptr que possui p, inicializar o ponteiro armazenado com p e de valor inicializar o deleter armazenados.

3-4)

Constrói um objeto que possui std::unique_ptr p, inicializar o ponteiro armazenado com p e inicializar um D deleter em baixo (depende se D é um tipo de referência)

a)

Se D é referência não A tipo, então as assinaturas são:

unique_ptr(pointer p, const A& d);

unique_ptr(pointer p, A&& d);

b)

Se D é um tipo A& lvalue-referência, então as assinaturas são:

unique_ptr(pointer p, A& d);

unique_ptr(pointer p, A&& d);

c)

Se D é um tipo const A& lvalue-referência, então as assinaturas são:

unique_ptr(pointer p, const A& d);

unique_ptr(pointer p, const A&& d);

5)

Constrói um unique_ptr por transferência de propriedade de u para *this.

6)

Constrói um std::unique_ptr vazio.

7)

Constrói um unique_ptr por transferência de propriedade de u para *this, onde u é construído com um deleter especificado (E). Ele depende se E é um tipo de referência, como a seguir:

a)

se E é um tipo de referência, este deleter é construído a partir de cópia de deleter u.

b)

se E é um tipo de referência não, este é deleter movimento construído a partir de deleter u de.

8)

Constrói um unique_ptr onde o ponteiro armazenado é inicializado com u.release() eo deleter valor armazenado é inicializado.

Parâmetros

p	-	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.
d1,d2	-	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.
u	-	outro ponteiro inteligente para adquirir a propriedade de Original: another smart pointer to 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

noexcept specification:


`noexcept`

(desde C++11)

Exemplo

#include <iostream>
#include <memory>

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

struct D{

    D(){};

    D(const D& other){
        std::cout << "call D const copy constructor... \n";
    }

    D(D& other){
        std::cout << "call D copy constructor... \n";
    }

    D(D&& other){
        std::cout << "call D move constructor... \n";
    }

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

int main()
{
    //constructor (1)
    std::cout << "Example constructor(1)...\n\n";
    std::unique_ptr<Foo> up;

    //constructor (2)
    std::cout << "Example constructor(2)...\n";
    Foo* f = new Foo();
    std::unique_ptr<Foo> up2(f); //up2 now owns f
    up2.reset();

    //constructor (3&4)
    std::cout << "Example constructor(3&4)...\n";

    //D is not an lvalue-reference - d is a non-const rvalue
    std::unique_ptr<Foo, D> up3(new Foo(), D()); //D must be MoveConstructible
    up3.reset();

    //D is not an lvalue-refernce - d is a left value
    D d2;
    std::unique_ptr<Foo, D> up4(new Foo(), d2); //D must be Copyconstructible
    up4.reset();

    //D is a left value reference type
    D d3;
    std::unique_ptr<Foo, D&> up5(new Foo(), d3); //up3 holds a reference to d3
    up5.reset();

    //D is a const left value reference type
    const D d4;
    std::unique_ptr<Foo, const D&> up6(new Foo(), d4);
    up6.reset();

    //constructor (5)
    std::cout << "Example constructor(5)...\n";
    std::unique_ptr<Foo> up7(new Foo());
    std::unique_ptr<Foo> up8(move(up7)); //ownership is transfered to up8
    up8.reset();

    //constructor 6
    std::cout << "Example constructor(6)...\n\n";
    std::unique_ptr<Foo> up9(nullptr);

    //constructor 7 - D is move constructed
    D d;
    std::cout << "Example constructor(7)...\n";
    std::unique_ptr<Foo, D> up10(new Foo(), d);     //D is not a reference
    std::unique_ptr<Foo, D> up11(move(up10));       //D is move constructed
    up11.reset();

    //constructor 7 - D is copy constructed
    std::unique_ptr<Foo, D&> up12(new Foo(), d);    //D is a reference
    std::unique_ptr<Foo, D> up13(move(up12));       //D is copy constructed
    up13.reset();

    //constructor 8
    std::cout << "Example constructor(8)...\n";
    std::auto_ptr<Foo> up14(new Foo());
    std::unique_ptr<Foo> up15(move(up14));
    up15.reset();

}

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::unique_ptr::unique_ptr

Parâmetros

Exceções

Exemplo

Navegação

Ferramentas