Làm cách nào để chuyển std :: unique_ptr vào một hàm

Làm cách nào để chuyển std::unique_ptrmột hàm vào một hàm? Giả sử tôi có lớp sau:

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

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

Sau đây không biên dịch:

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

Tại sao tôi không thể truyền a std::unique_ptrvào một hàm? Chắc chắn đây là mục đích chính của cấu trúc? Hay ủy ban C ++ có ý định cho tôi quay lại con trỏ kiểu C thô và chuyển nó như thế này:

MyFunc(&(*ptr)); 

Và kỳ lạ nhất, tại sao đây lại là một cách tốt để vượt qua nó? Nó có vẻ không nhất quán kinh khủng:

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

Về cơ bản có hai tùy chọn ở đây:

Chuyển con trỏ thông minh bằng cách tham chiếu

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

Di chuyển con trỏ thông minh vào đối số hàm

Lưu ý rằng trong trường hợp này, khẳng định sẽ giữ nguyên!

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

Bạn đang chuyển nó theo giá trị, nghĩa là tạo một bản sao. Nó sẽ không phải là rất độc đáo, phải không?

Bạn có thể di chuyển giá trị, nhưng điều đó có nghĩa là chuyển quyền sở hữu đối tượng và quyền kiểm soát thời gian tồn tại của nó cho hàm.

Nếu thời gian tồn tại của đối tượng được đảm bảo tồn tại trong suốt thời gian gọi đến MyFunc, chỉ cần chuyển một con trỏ thô qua ptr.get().

Tại sao tôi không thể truyền a unique_ptrvào một hàm?

Bạn không thể làm điều đó vì unique_ptrcó một phương thức khởi tạo di chuyển nhưng không có một phương thức khởi tạo sao chép. Theo tiêu chuẩn, khi một phương thức khởi tạo di chuyển được xác định nhưng một phương thức khởi tạo sao chép không được xác định, thì phương thức tạo bản sao sẽ bị xóa.

12.8 Sao chép và di chuyển các đối tượng lớp

...

7 Nếu định nghĩa lớp không khai báo rõ ràng một phương thức khởi tạo sao chép, thì một phương thức được khai báo ngầm định. Nếu định nghĩa lớp khai báo một phương thức khởi tạo di chuyển hoặc toán tử gán di chuyển, phương thức khởi tạo sao chép được khai báo ngầm định được định nghĩa là đã xóa;

Bạn có thể chuyển hàm unique_ptrcho hàm bằng cách sử dụng:

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

và sử dụng nó như bạn có:

hoặc là

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

và sử dụng nó như:

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

Lưu ý quan trọng

Xin lưu ý rằng nếu bạn sử dụng phương pháp thứ hai, ptrkhông có quyền sở hữu con trỏ sau khi gọi std::move(ptr)trả về.

void MyFunc(std::unique_ptr<A>&& arg)sẽ có cùng tác dụng void MyFunc(std::unique_ptr<A>& arg)vì cả hai đều là tham chiếu.

Trong trường hợp đầu tiên, ptrvẫn có quyền sở hữu con trỏ sau cuộc gọi tới MyFunc.

Vì MyFunckhông có quyền sở hữu, sẽ tốt hơn nếu có:

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

hoặc tốt hơn

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

Nếu bạn thực sự muốn có quyền sở hữu, bạn phải di chuyển tài nguyên của mình:

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

hoặc chuyển trực tiếp tham chiếu giá trị r:

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

std::unique_ptr không cố ý sao chép để đảm bảo chỉ có một chủ sở hữu.

Tại sao tôi không thể truyền a unique_ptrvào một hàm?

Bạn có thể, nhưng không phải bằng cách sao chép - bởi vì std::unique_ptr<>không phải là bản sao có thể xây dựng.

Chắc chắn đây là mục đích chính của cấu trúc?

Trong số những thứ khác, std::unique_ptr<>được thiết kế để đánh dấu rõ ràng quyền sở hữu duy nhất (trái ngược với std::shared_ptr<>).

Và kỳ lạ nhất, tại sao đây lại là một cách tốt để vượt qua nó?

Bởi vì trong trường hợp đó, không có bản sao-xây dựng.

Vì unique_ptrlà quyền sở hữu duy nhất, nếu bạn muốn chuyển nó dưới dạng đối số, hãy thử

MyFunc(move(ptr));

Nhưng sau đó trạng thái ptrtrong mainsẽ được nullptr.

Truyền std::unique_ptr<T>dưới dạng giá trị cho một hàm không hoạt động vì, như các bạn đã đề cập, unique_ptrkhông thể sao chép được.

Cái này thì sao?

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

mã này đang hoạt động