ฉันจะส่ง std :: unique_ptr ไปยังฟังก์ชันได้อย่างไร

ฉันจะส่งผ่านstd::unique_ptrเข้าสู่ฟังก์ชันได้อย่างไร? บอกว่าฉันมีคลาสต่อไปนี้:

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

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

ต่อไปนี้ไม่ได้รวบรวม:

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

เหตุใดฉันจึงไม่สามารถส่งผ่านstd::unique_ptrเข้าสู่ฟังก์ชันได้ แน่นอนว่านี่คือจุดประสงค์หลักของการสร้าง? หรือว่าคณะกรรมการ C ++ ตั้งใจให้ฉันถอยกลับไปใช้พอยน์เตอร์สไตล์ C แบบดิบแล้วส่งต่อแบบนี้:

MyFunc(&(*ptr)); 

และที่แปลกที่สุดทำไมนี่ถึงเป็นวิธีที่ใช้ได้? ดูเหมือนไม่สอดคล้องกันอย่างน่ากลัว:

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

โดยทั่วไปมีสองตัวเลือกที่นี่:

ส่งสมาร์ทพอยน์เตอร์โดยอ้างอิง

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

ย้ายตัวชี้อัจฉริยะไปที่อาร์กิวเมนต์ของฟังก์ชัน

โปรดทราบว่าในกรณีนี้การยืนยันจะถือ!

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

คุณส่งผ่านค่าซึ่งหมายถึงการทำสำเนา มันจะไม่ซ้ำกันมากใช่มั้ย?

คุณสามารถย้ายค่าได้ แต่นั่นหมายถึงการส่งผ่านความเป็นเจ้าของวัตถุและการควบคุมอายุการใช้งานไปยังฟังก์ชัน

หากอายุการใช้งานของวัตถุที่มีการประกันเพื่ออยู่ตลอดระยะเวลาของการเรียกร้องให้ MyFunc ptr.get()เพียงผ่านตัวชี้ดิบผ่าน

เหตุใดฉันจึงไม่สามารถส่งผ่านunique_ptrเข้าสู่ฟังก์ชันได้

คุณไม่สามารถทำได้เนื่องจากunique_ptrมีตัวสร้างการย้าย แต่ไม่ใช่ตัวสร้างการคัดลอก ตามมาตรฐานเมื่อกำหนดตัวสร้างการย้าย แต่ไม่ได้กำหนดตัวสร้างการคัดลอกตัวสร้างการคัดลอกจะถูกลบ

12.8 คัดลอกและย้ายคลาสออบเจ็กต์

...

7 ถ้านิยามคลาสไม่ได้ประกาศตัวสร้างการคัดลอกอย่างชัดเจนจะมีการประกาศตัวสร้างการคัดลอกโดยปริยาย ถ้านิยามคลาสประกาศตัวสร้างการย้ายหรือตัวดำเนินการกำหนดย้ายตัวสร้างการคัดลอกที่ประกาศโดยปริยายจะถูกกำหนดเป็นลบ

คุณสามารถส่งผ่านunique_ptrไปยังฟังก์ชันได้โดยใช้:

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

และใช้มันอย่างที่คุณมี:

หรือ

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

และใช้มันเช่น:

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

โน๊ตสำคัญ

โปรดทราบว่าหากคุณใช้วิธีที่สองptrจะไม่มีความเป็นเจ้าของตัวชี้หลังจากเรียกให้std::move(ptr)ส่งคืน

void MyFunc(std::unique_ptr<A>&& arg)จะมีผลเช่นเดียวกันvoid MyFunc(std::unique_ptr<A>& arg)เนื่องจากทั้งสองเป็นการอ้างอิง

ในกรณีแรกที่ยังคงมีความเป็นเจ้าของของตัวชี้หลังจากการเรียกร้องให้ptrMyFunc

เนื่องจากMyFuncไม่ได้เป็นเจ้าของมันจะดีกว่าถ้ามี:

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

หรือดีกว่า

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

หากคุณต้องการเป็นเจ้าของจริงๆคุณต้องย้ายทรัพยากรของคุณ:

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

หรือส่งต่อการอ้างอิง r-value โดยตรง:

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

std::unique_ptr ไม่มีสำเนาโดยมีวัตถุประสงค์เพื่อรับประกันว่าจะมีเจ้าของเพียงคนเดียว

เหตุใดฉันจึงไม่สามารถส่งผ่านunique_ptrเข้าสู่ฟังก์ชันได้

คุณทำได้ แต่ไม่ใช่โดยการคัดลอก - เนื่องจากstd::unique_ptr<>ไม่สามารถคัดลอกได้

แน่นอนว่านี่คือจุดประสงค์หลักของการสร้าง?

เหนือสิ่งอื่นใดstd::unique_ptr<>ออกแบบมาเพื่อระบุความเป็นเจ้าของที่ไม่เหมือนใครอย่างชัดเจน (ตรงข้ามกับstd::shared_ptr<>)

และที่แปลกที่สุดทำไมนี่ถึงเป็นวิธีที่ใช้ได้?

เนื่องจากในกรณีนั้นไม่มีการสร้างสำเนา

เนื่องจากunique_ptrมีไว้สำหรับความเป็นเจ้าของที่ไม่ซ้ำกันหากคุณต้องการส่งผ่านเป็นอาร์กิวเมนต์ลอง

MyFunc(move(ptr));

แต่หลังจากนั้นสถานะptrในmainจะเป็นnullptrอย่างไร

การส่งผ่านstd::unique_ptr<T>เป็นค่าไปยังฟังก์ชันใช้งานไม่ได้เพราะอย่างที่พวกคุณพูดถึงunique_ptrนั้นไม่สามารถคัดลอกได้

อะไรประมาณนี้

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

รหัสนี้ใช้งานได้