Copie o construtor para uma classe com unique_ptr

Como faço para implementar um construtor de cópia para uma classe que possui uma unique_ptrvariável de membro? Estou considerando apenas o C ++ 11.

Uma vez que o unique_ptrnão pode ser compartilhado, você precisa copiar profundamente seu conteúdo ou convertê-lo unique_ptrem um shared_ptr.

class A
{
   std::unique_ptr< int > up_;

public:
   A( int i ) : up_( new int( i ) ) {}
   A( const A& a ) : up_( new int( *a.up_ ) ) {}
};

int main()
{
   A a( 42 );
   A b = a;
}

Você pode, como o NPE mencionou, usar um move-ctor em vez de um copy-ctor, mas isso resultaria em semânticas diferentes de sua classe. Um move-ctor precisaria fazer o membro como móvel explicitamente via std::move:

A( A&& a ) : up_( std::move( a.up_ ) ) {}

Ter um conjunto completo de operadores necessários também leva a

A& operator=( const A& a )
{
   up_.reset( new int( *a.up_ ) );
   return *this,
}

A& operator=( A&& a )
{
   up_ = std::move( a.up_ );
   return *this,
}

Se quiser usar sua classe em a std::vector, você basicamente terá que decidir se o vetor deve ser o único proprietário de um objeto, caso em que seria suficiente para tornar a classe móvel, mas não copiável. Se você deixar de fora o copy-ctor e a atribuição de cópia, o compilador irá guiá-lo sobre como usar um std :: vector com tipos move-only.

O caso usual de alguém ter um unique_ptrem uma classe é ser capaz de usar herança (caso contrário, um objeto simples faria o mesmo, consulte RAII). Para este caso, não há uma resposta apropriada neste tópico até agora .

Então, aqui está o ponto de partida:

struct Base
{
    //some stuff
};

struct Derived : public Base
{
    //some stuff
};

struct Foo
{
    std::unique_ptr<Base> ptr;  //points to Derived or some other derived class
};

... e o objetivo é, como disse, tornar Foocopiável.

Para isso, é necessário fazer uma cópia detalhada do ponteiro contido para garantir que a classe derivada seja copiada corretamente.

Isso pode ser feito adicionando o seguinte código:

struct Base
{
    //some stuff

    auto clone() const { return std::unique_ptr<Base>(clone_impl()); }
protected:
    virtual Base* clone_impl() const = 0;
};

struct Derived : public Base
{
    //some stuff

protected:
    virtual Derived* clone_impl() const override { return new Derived(*this); };                                                 
};

struct Foo
{
    std::unique_ptr<Base> ptr;  //points to Derived or some other derived class

    //rule of five
    ~Foo() = default;
    Foo(Foo const& other) : ptr(other.ptr->clone()) {}
    Foo(Foo && other) = default;
    Foo& operator=(Foo const& other) { ptr = other.ptr->clone(); return *this; }
    Foo& operator=(Foo && other) = default;
};

Existem basicamente duas coisas acontecendo aqui:

• A primeira é a adição de construtores de cópia e movimentação, que são excluídos implicitamente à Foomedida que o construtor de cópia de unique_ptré excluído. O construtor de movimento pode ser adicionado simplesmente por = default... o que é apenas para deixar o compilador saber que o construtor de movimento usual não deve ser excluído (isso funciona, pois unique_ptrjá tem um construtor de movimento que pode ser usado neste caso).

  Para o construtor de cópia de Foo, não há mecanismo semelhante, pois não há construtor de cópia de unique_ptr. Portanto, é preciso construir um novo unique_ptr, preenchê-lo com uma cópia da ponta original e usá-lo como membro da classe copiada.

• No caso de herança estar envolvida, a cópia da ponta original deve ser feita com cuidado. A razão é que fazer uma cópia simples via std::unique_ptr<Base>(*ptr)código acima resultaria em fracionamento, ou seja, apenas o componente base do objeto é copiado, enquanto a parte derivada está faltando.

  Para evitar isso, a cópia deve ser feita por meio do padrão de clone. A ideia é fazer a cópia por meio de uma função virtual clone_impl()que retorna um Base*na classe base. Na classe derivada, no entanto, ele é estendido por meio de covariância para retornar a Derived*, e esse ponteiro aponta para uma cópia recém-criada da classe derivada. A classe base pode então acessar esse novo objeto por meio do ponteiro da classe base Base*, envolvê-lo em um unique_ptre retorná-lo por meio da clone()função real que é chamada de fora.

Experimente este auxiliar para criar cópias profundas e lidar com a origem de unique_ptr nulo.

    template< class T >
    std::unique_ptr<T> copy_unique(const std::unique_ptr<T>& source)
    {
        return source ? std::make_unique<T>(*source) : nullptr;
    }

Por exemplo:

class My
{
    My( const My& rhs )
        : member( copy_unique(rhs.member) )
    {
    }

    // ... other methods

private:
    std::unique_ptr<SomeType> member;
};

Daniel Frey mencionou sobre a solução de cópia, gostaria de falar sobre como mover o unique_ptr

#include <memory>
class A
{
  public:
    A() : a_(new int(33)) {}

    A(A &&data) : a_(std::move(data.a_))
    {
    }

    A& operator=(A &&data)
    {
      a_ = std::move(data.a_);
      return *this;
    }

  private:
    std::unique_ptr<int> a_;
};

Eles são chamados de construtor de movimento e atribuição de movimento

você poderia usá-los assim

int main()
{
  A a;
  A b(std::move(a)); //this will call move constructor, transfer the resource of a to b

  A c;
  a = std::move(c); //this will call move assignment, transfer the resource of c to a

}

Você precisa envolver aec por std :: move porque eles têm um nome std :: move está dizendo ao compilador para transformar o valor em referência de rvalue quaisquer que sejam os parâmetros. Em sentido técnico, std :: move é uma analogia com algo como " std :: rvalue "

Depois de mover, o recurso do unique_ptr é transferido para outro unique_ptr

Existem muitos tópicos que documentam a referência de rvalue; este é muito fácil para começar .

Editar:

O objeto movido deve permanecer válido, mas em estado não especificado .

C ++ primer 5, ch13 também dá uma boa explicação sobre como "mover" o objeto

Eu sugiro usar make_unique

class A
{
   std::unique_ptr< int > up_;

public:
   A( int i ) : up_(std::make_unique<int>(i)) {}
   A( const A& a ) : up_(std::make_unique<int>(*a.up_)) {};

int main()
{
   A a( 42 );
   A b = a;
}

unique_ptr não é copiável, é apenas móvel.

Isso afetará diretamente o Teste, que é, em seu segundo exemplo, também apenas móvel e não copiável.

Na verdade, é bom que você use o unique_ptrque o protege de um grande erro.

Por exemplo, o principal problema com seu primeiro código é que o ponteiro nunca é excluído, o que é muito, muito ruim. Diga, você consertaria isso:

class Test
{
    int* ptr; // writing this in one line is meh, not sure if even standard C++

    Test() : ptr(new int(10)) {}
    ~Test() {delete ptr;}
};

int main()
{       
     Test o;
     Test t = o;
}

Isso também é ruim. O que acontece, se você copiar Test? Haverá duas classes com um ponteiro que aponta para o mesmo endereço.

Quando um Testé destruído, ele também destrói o ponteiro. Quando o segundo Testfor destruído, ele tentará remover a memória atrás do ponteiro também. Mas ele já foi excluído e obteremos algum erro de runtime de acesso à memória ruim (ou comportamento indefinido se não tivermos sorte).

Portanto, a maneira certa é implementar o construtor de cópia e o operador de atribuição de cópia, para que o comportamento seja claro e possamos criar uma cópia.

unique_ptrestá muito à nossa frente aqui. Ele tem o significado semântico: “ Eu sou unique, então você não pode simplesmente me copiar. ” Assim, nos impede de cometer o erro de implementar agora os operadores em questão.

Você pode definir o construtor de cópia e o operador de atribuição de cópia para um comportamento especial e seu código funcionará. Mas você é, com razão (!), Forçado a fazer isso.

Moral da história: use sempre unique_ptrnesse tipo de situação.