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

std::unique_ptr é um ponteiro inteligente que:

• detém a propriedade exclusiva de um objeto através de um ponteiro, e
• destrói o objeto apontado quando o unique_ptr sai do escopo.

O unique_ptr não pode ser copiado nem transferido por cópia. Um objeto não pode ser gerido por duas instâncias diferentes de unique_ptr. Um unique_ptr não-const pode transferir a propriedade do objeto gerido para outro unique_ptr; já um const std::unique_ptr não pode ser transferido, o que limita o tempo de vida do objeto gerido ao escopo onde o ponteiro foi criado. Quando o unique_ptr é destruído, ele descarta o objeto através de Deleter. Existem duas versões do std::unique_ptr:

Os usos típicos de std::unique_ptr incluem:

• proporcionando segurança exceção a classes e funções que manipulam objetos com vida dinâmica, garantindo a eliminação de ambos saída normal e saída através de exceção.

  Original:

  providing exception safety to classes and functions that handle objects with dynamic lifetime, by guaranteeing deletion on both normal exit and exit through exception.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• passando a propriedade de objetos de propriedade exclusiva com vida dinâmica em funções

  Original:

  passing ownership of uniquely-owned objects with dynamic lifetime into functions

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• a aquisição da propriedade de objetos de propriedade exclusiva com vida dinâmica de funções

  Original:

  acquiring ownership of uniquely-owned objects with dynamic lifetime from functions

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• como o tipo de elemento em movimento de reconhecimento de recipientes, como std::vector, que possuem ponteiros para objetos dinamicamente alocados, por exemplo, se o comportamento polimórfico é desejado

  Original:

  as the element type in move-aware containers, such as std::vector, which hold pointers to dynamically-allocated objects, e.g. if polymorphic behavior is desired

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

[editar] Tipos de membro

[editar] Funções de membro

[editar] Não-membros funções

[editar] Classes auxiliares

[editar] Exemplo

#include <iostream>
#include <memory>
 
struct Foo {
    Foo() { std::cout << "Foo::Foo\n"; }
    ~Foo() { std::cout << "Foo::~Foo\n"; }
    void bar() { std::cout << "Foo::bar\n"; }
};
 
void f(const Foo &foo)
{
    std::cout << "f(const Foo&)\n";
}
 
int main()
{
    std::unique_ptr<Foo> p1(new Foo);  // p1 owns Foo
    if (p1) p1->bar();
 
    {
        std::unique_ptr<Foo> p2(std::move(p1));  // now p2 owns Foo
        f(*p2);
 
        p1 = std::move(p2);  // ownership returns to p1
        std::cout << "destroying p2...\n";
    }
 
    if (p1) p1->bar();
 
    // Foo instance is destroyed when p1 goes out of scope
}

Foo::Foo
Foo::bar
f(const Foo&)
destroying p2...
Foo::bar
Foo::~Foo