Salin konstruktor untuk kelas dengan unique_ptr

Bagaimana cara menerapkan konstruktor salinan untuk kelas yang memiliki unique_ptrvariabel anggota? Saya hanya mempertimbangkan C ++ 11.

Karena unique_ptrtidak dapat dibagikan, Anda perlu menyalin kontennya atau mengonversinya unique_ptrmenjadi file 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;
}

Anda dapat, seperti yang disebutkan NPE, menggunakan move-ctor, bukan copy-ctor, tetapi itu akan menghasilkan semantik yang berbeda di kelas Anda. Seorang pemindah perlu membuat anggotanya dapat dipindahkan secara eksplisit melalui std::move:

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

Memiliki satu set lengkap operator yang diperlukan juga mengarah ke

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

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

Jika Anda ingin menggunakan kelas Anda dalam a std::vector, pada dasarnya Anda harus memutuskan apakah vektor akan menjadi pemilik unik suatu objek, dalam hal ini akan cukup untuk membuat kelas dapat dipindahkan, tetapi tidak dapat disalin. Jika Anda mengabaikan copy-ctor dan copy-assignment, kompilator akan memandu cara Anda menggunakan std :: vector dengan tipe hanya-bergerak.

Kasus umum bagi seseorang untuk memiliki a unique_ptrdi kelas adalah dapat menggunakan pewarisan (jika tidak, objek biasa akan sering melakukannya juga, lihat RAII). Untuk kasus ini, sampai saat ini belum ada jawaban yang sesuai di thread ini .

Jadi, inilah titik awalnya:

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
};

... dan tujuannya adalah, seperti yang dikatakan, membuat dapat Foodisalin.

Untuk ini, seseorang perlu melakukan salinan mendalam dari penunjuk yang ada untuk memastikan kelas turunan disalin dengan benar.

Ini dapat dilakukan dengan menambahkan kode berikut:

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;
};

Pada dasarnya ada dua hal yang terjadi di sini:

• Yang pertama adalah penambahan konstruktor salin dan pindahkan, yang secara implisit dihapus Foosaat konstruktor salinan unique_ptrdihapus. Konstruktor move dapat ditambahkan hanya dengan = default... yang hanya untuk memberi tahu kompiler bahwa konstruktor move biasa tidak boleh dihapus (ini berfungsi, karena unique_ptrsudah memiliki konstruktor move yang dapat digunakan dalam kasus ini).

  Untuk pembuat salinan Foo, tidak ada mekanisme yang sama karena tidak ada pembuat salinan unique_ptr. Jadi, seseorang harus membuat yang baru unique_ptr, mengisinya dengan salinan poin asli, dan menggunakannya sebagai anggota kelas yang disalin.

• Dalam hal warisan terlibat, salinan penerima asli harus dilakukan dengan hati-hati. Alasannya adalah bahwa melakukan penyalinan sederhana melalui std::unique_ptr<Base>(*ptr)kode di atas akan menghasilkan pemotongan, yaitu, hanya komponen dasar objek yang disalin, sedangkan bagian turunannya hilang.

  Untuk menghindari hal ini, penyalinan harus dilakukan melalui pola klon. Idenya adalah untuk melakukan penyalinan melalui fungsi virtual clone_impl()yang mengembalikan a Base*di kelas dasar. Dalam kelas turunan, bagaimanapun, itu diperpanjang melalui kovarians untuk mengembalikan a Derived*, dan penunjuk ini menunjuk ke salinan yang baru dibuat dari kelas turunan. Kelas dasar kemudian dapat mengakses objek baru ini melalui penunjuk kelas dasar Base*, membungkusnya menjadi a unique_ptr, dan mengembalikannya melalui clone()fungsi aktual yang dipanggil dari luar.

Coba helper ini untuk membuat salinan dalam, dan atasi ketika sumber unique_ptr adalah null.

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

Misalnya:

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

    // ... other methods

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

Daniel Frey menyebutkan tentang solusi salinan, saya akan berbicara tentang cara memindahkan 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_;
};

Mereka disebut konstruktor bergerak dan tugas pindah

Anda bisa menggunakannya seperti ini

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

}

Anda perlu membungkus a dan c dengan std :: move karena mereka memiliki nama std :: move memberi tahu kompiler untuk mengubah nilai menjadi referensi rvalue apa pun parameternya Dalam pengertian teknis, std :: move adalah analogi dengan sesuatu seperti " std :: rvalue "

Setelah dipindahkan, sumber daya unique_ptr ditransfer ke unique_ptr lain

Ada banyak topik yang mendokumentasikan rvalue referensi; ini cukup mudah untuk memulai .

Edit:

Objek yang dipindahkan akan tetap valid tetapi statusnya tidak ditentukan .

C ++ primer 5, ch13 juga memberikan penjelasan yang sangat bagus tentang bagaimana "memindahkan" objek

Saya sarankan gunakan 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 tidak dapat disalin, hanya dapat dipindahkan.

Ini secara langsung akan memengaruhi Test, yang, pada contoh kedua Anda, juga hanya dapat dipindahkan dan tidak dapat disalin.

Faktanya, ada baiknya Anda menggunakan unique_ptryang melindungi Anda dari kesalahan besar.

Misalnya, masalah utama dengan kode pertama Anda adalah bahwa penunjuk tidak pernah dihapus yang benar-benar buruk. Katakan, Anda akan memperbaikinya dengan:

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;
}

Ini juga buruk. Apa yang terjadi, jika Anda menyalin Test? Akan ada dua kelas yang memiliki penunjuk yang menunjuk ke alamat yang sama.

Ketika salah satu Testdihancurkan, itu juga akan menghancurkan penunjuk. Saat detik Anda Testhancur, ia juga akan mencoba menghapus memori di belakang penunjuk. Tetapi itu telah dihapus dan kami akan mendapatkan beberapa kesalahan runtime akses memori yang buruk (atau perilaku tidak ditentukan jika kami tidak beruntung).

Jadi, cara yang benar adalah dengan mengimplementasikan copy constructor dan copy assignment operator, sehingga perilakunya jelas dan kita bisa membuat salinannya.

unique_ptrjauh di depan kita di sini. Ini memiliki arti semantik: " Saya unique, jadi Anda tidak bisa begitu saja menyalin saya. " Jadi, ini mencegah kita dari kesalahan sekarang menerapkan operator yang ada.

Anda dapat menentukan copy constructor dan menyalin operator penugasan untuk perilaku khusus dan kode Anda akan berfungsi. Tapi Anda, memang (!), Dipaksa untuk melakukan itu.

Moral cerita: selalu gunakan unique_ptrdalam situasi seperti ini.