Làm thế nào để chụp một unique_ptr thành một biểu thức lambda?

Question

Tôi đã thử các cách sau:

std::function<void()> getAction(std::unique_ptr<MyClass> &&psomething){ 
    //The caller given ownership of psomething 
    return [psomething](){ 
     psomething->do_some_thing(); 
     //psomething is expected to be released after this point 
    }; 
} 

Nhưng nó không biên dịch. Bất kỳ ý tưởng?

UPDATE:

AS đề nghị, một số cú pháp mới là cần thiết để xác định một cách rõ ràng chúng ta cần phải chuyển quyền sở hữu cho lambda, bây giờ tôi đang suy nghĩ về cú pháp sau:

std::function<void()> getAction(std::unique_ptr<MyClass> psomething){ 
    //The caller given ownership of psomething 
    return [auto psomething=move(psomething)](){ 
     psomething->do_some_thing(); 
     //psomething is expected to be released after this point 
    }; 
} 

Nó sẽ là một ứng cử viên tốt?

UPDATE 1:

tôi sẽ giới thiệu thực hiện của tôi move và copy như sau:

template<typename T> 
T copy(const T &t) { 
    return t; 
} 

//process lvalue references 
template<typename T> 
T move(T &t) { 
    return std::move(t); 
} 

class A{/*...*/}; 

void test(A &&a); 

int main(int, char **){ 
    A a; 
    test(copy(a)); //OK, copied 
    test(move(a)); //OK, moved 
    test(A());  //OK, temporary object 
    test(copy(A())); //OK, copying temporary object 
    //You can disable this behavior by letting copy accepts T & 
    //test(move(A())); You should never move a temporary object 
    //It is not good to have a rvalue version of move. 
    //test(a); forbidden, you have to say weather you want to copy or move 
    //from a lvalue reference. 
} 

Answer 1

Vấn đề này được giải quyết bằng lambda generalized capture trong C++ 14:

// a unique_ptr is move-only 
auto u = make_unique<some_type>(some, parameters); 

// move the unique_ptr into the lambda 
go.run([u = move(u)]{do_something_with(u);}); 

Answer 2

Bạn có thể không vĩnh viễn chụp một unique_ptr trong một lambda. Thật vậy, nếu bạn muốn chụp vĩnh viễn bất kỳ thứ gì trong một lambda, nó phải là có thể sao chép; chỉ đơn thuần là di chuyển là không đủ.

Điều này có thể được coi là lỗi trong C++ 11, nhưng bạn sẽ cần một số cú pháp để nói rõ ràng rằng bạn muốn di chuyển giá trị unique_ptr vào lambda. Đặc điểm kỹ thuật C++ 11 được viết rất cẩn thận để ngăn chặn các chuyển động tiềm ẩn trên các biến được đặt tên; đó là lý do tại sao std::move tồn tại và đây là một điều tốt.

Để thực hiện những gì bạn muốn, hãy yêu cầu sử dụng std::bind (sẽ được bán phức tạp, yêu cầu một chuỗi ngắn binds) hoặc chỉ trả về một đối tượng cũ thông thường.

Ngoài ra, không bao giờ lấy unique_ptr bởi &&, trừ khi bạn đang thực sự viết hàm khởi tạo của nó. Chỉ lấy nó theo giá trị; cách duy nhất mà người dùng có thể cung cấp theo giá trị là với std::move. Thật vậy, nó thường là một ý tưởng tốt để không bao giờ lấy bất cứ điều gì bởi &&, trừ khi bạn đang viết toán tử khởi tạo/gán (hoặc thực hiện một hàm chuyển tiếp).

Answer 3

Các "bán phức tạp" giải pháp sử dụng std::bind như đã đề cập bởi Nicol Bolas không phải là quá xấu sau khi tất cả:

std::function<void()> getAction(std::unique_ptr<MyClass>&& psomething) 
{ 
    return std::bind([] (std::unique_ptr<MyClass>& p) { p->do_some_thing(); }, 
        std::move(psomething)); 
} 

Answer 4

Một giải pháp tối ưu phụ làm việc cho tôi là chuyển đổi unique_ptr thành shared_ptr và sau đó chụp shared_ptr trong lambda.

std::function<void()> getAction(std::unique_ptr<MyClass> psomething) 
{ 
    //The caller given ownership of psomething 
    std::shared_ptr<MyClass> psomethingShared = std::shared_ptr<MyClass>(std::move(psomething)); 
    return [psomethingShared]() 
    { 
     psomethingShared->do_some_thing(); 
    }; 
} 

Answer 5

tôi đã sử dụng workaround thực sự tinh ranh này, trong đó bao gồm gắn bó các unique_ptr bên trong một shared_ptr. Điều này là do mã của tôi yêu cầu unique_ptr (do hạn chế API) nên tôi không thể chuyển đổi nó thành shared_ptr (nếu không tôi không bao giờ có thể lấy lại được unique_ptr).

Lý do chính đáng của tôi để sử dụng tính năng hủy bỏ này là mã số thử nghiệm của tôi và tôi đã phải std::bind a unique_ptr vào cuộc gọi hàm thử nghiệm.

// Put unique_ptr inside a shared_ptr 
auto sh = std::make_shared<std::unique_ptr<Type>>(std::move(unique)); 

std::function<void()> fnTest = std::bind([this, sh, input, output]() { 
    // Move unique_ptr back out of shared_ptr 
    auto unique = std::move(*sh.get()); 

    // Make sure unique_ptr is still valid 
    assert(unique); 

    // Move unique_ptr over to final function while calling it 
    this->run_test(std::move(unique), input, output); 
}); 

Bây giờ gọi fnTest() sẽ gọi run_test() khi đi qua các unique_ptr với nó. Gọi fnTest() lần thứ hai sẽ dẫn đến lỗi xác nhận, vì unique_ptr đã bị di chuyển/bị mất trong lần gọi đầu tiên.