Bagaimana cara mengirimkan std :: unique_ptr ke dalam suatu fungsi

Bagaimana cara mengirimkan a std::unique_ptrke suatu fungsi? Katakanlah saya memiliki kelas berikut:

class A
{
public:
    A(int val)
    {
        _val = val;
    }

    int GetVal() { return _val; }
private:
    int _val;
};

Berikut ini tidak dapat dikompilasi:

void MyFunc(unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(ptr);

    return 0;
}

Mengapa saya tidak dapat meneruskan a std::unique_ptrke suatu fungsi? Tentunya ini tujuan utama dari konstruksinya? Atau apakah komite C ++ bermaksud agar saya kembali ke petunjuk gaya C mentah dan meneruskannya seperti ini:

MyFunc(&(*ptr)); 

Dan yang paling aneh dari semuanya, mengapa ini cara yang OK untuk melewatinya? Tampaknya sangat tidak konsisten:

MyFunc(unique_ptr<A>(new A(1234)));

Pada dasarnya ada dua opsi di sini:

Meneruskan penunjuk cerdas dengan referensi

void MyFunc(unique_ptr<A> & arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(ptr);
}

Pindahkan penunjuk cerdas ke dalam argumen fungsi

Perhatikan bahwa dalam kasus ini, pernyataan akan berlaku!

void MyFunc(unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(move(ptr));
    assert(ptr == nullptr)
}

Anda meneruskannya dengan nilai, yang berarti membuat salinan. Itu tidak terlalu unik, bukan?

Anda bisa memindahkan nilainya, tetapi itu berarti meneruskan kepemilikan objek dan kontrol masa pakainya ke fungsi.

Jika masa pakai objek dijamin ada selama masa panggilan ke MyFunc, teruskan saja pointer mentah melalui ptr.get().

Mengapa saya tidak dapat meneruskan a unique_ptrke suatu fungsi?

Anda tidak dapat melakukannya karena unique_ptrmemiliki konstruktor pemindahan tetapi bukan konstruktor salinan. Menurut standar, ketika konstruktor pemindahan ditentukan tetapi konstruktor salinan tidak ditentukan, konstruktor salinan dihapus.

12.8 Menyalin dan memindahkan objek kelas

...

7 Jika definisi kelas tidak secara eksplisit mendeklarasikan salinan konstruktor, satu akan dideklarasikan secara implisit. Jika definisi kelas mendeklarasikan konstruktor pemindahan atau operator penugasan pindah, konstruktor salinan yang dideklarasikan secara implisit didefinisikan sebagai dihapus;

Anda dapat meneruskan unique_ptrke fungsi dengan menggunakan:

void MyFunc(std::unique_ptr<A>& arg)
{
    cout << arg->GetVal() << endl;
}

dan gunakan seperti yang Anda miliki:

atau

void MyFunc(std::unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

dan gunakan seperti:

std::unique_ptr<A> ptr = std::unique_ptr<A>(new A(1234));
MyFunc(std::move(ptr));

Catatan penting

Harap dicatat bahwa jika Anda menggunakan metode kedua, ptrtidak memiliki kepemilikan pointer setelah panggilan untuk std::move(ptr)kembali.

void MyFunc(std::unique_ptr<A>&& arg)akan memiliki efek yang sama void MyFunc(std::unique_ptr<A>& arg)karena keduanya adalah referensi.

Dalam kasus pertama, ptrmasih memiliki kepemilikan penunjuk setelah panggilan ke MyFunc.

Karena MyFunctidak mengambil kepemilikan, akan lebih baik untuk memiliki:

void MyFunc(const A* arg)
{
    assert(arg != nullptr); // or throw ?
    cout << arg->GetVal() << endl;
}

atau lebih baik

void MyFunc(const A& arg)
{
    cout << arg.GetVal() << endl;
}

Jika Anda benar-benar ingin mengambil alih kepemilikan, Anda harus memindahkan sumber daya Anda:

std::unique_ptr<A> ptr = std::make_unique<A>(1234);
MyFunc(std::move(ptr));

atau berikan referensi nilai-r secara langsung:

MyFunc(std::make_unique<A>(1234));

std::unique_ptr tidak memiliki salinan dengan tujuan untuk menjamin hanya memiliki satu pemilik.

Mengapa saya tidak dapat meneruskan a unique_ptrke suatu fungsi?

Anda bisa, tetapi tidak dengan menyalin - karena std::unique_ptr<>tidak dapat dibuat salinan.

Tentunya ini tujuan utama dari konstruksinya?

Antara lain, std::unique_ptr<>dirancang untuk secara tegas menandai kepemilikan unik (sebagai lawan std::shared_ptr<>).

Dan yang paling aneh dari semuanya, mengapa ini cara yang OK untuk melewatinya?

Karena dalam kasus itu, tidak ada konstruksi salinan.

Karena unique_ptruntuk kepemilikan unik, jika Anda ingin menyebarkannya sebagai argumen coba

MyFunc(move(ptr));

Tetapi setelah itu keadaan ptrdalam mainakan menjadi nullptr.

Meneruskan std::unique_ptr<T>sebagai nilai ke suatu fungsi tidak berfungsi karena, seperti yang Anda sebutkan, unique_ptrtidak dapat disalin.

Bagaimana dengan ini?

std::unique_ptr<T> getSomething()
{
   auto ptr = std::make_unique<T>();
   return ptr;
}

kode ini berfungsi