Sử dụng C++ 11 lambdas không đồng bộ, an toàn

Question

Tôi đã đến C++ 11 từ một nền Objective-C, và một điều tôi đang gặp khó khăn để đến với các điều khoản khác nhau là ngữ nghĩa bắt giữ của C++ 11 lambdas vs Objective-C "khối". (Xem here để so sánh).

Trong mục tiêu-C, như C++, con trỏ self/this bị ẩn hoàn toàn nếu bạn tham chiếu đến biến thành viên. Nhưng bởi vì tất cả các đối tượng trong Objective-C là một cách hiệu quả "con trỏ được chia sẻ", sử dụng thuật ngữ C++, bạn có thể làm điều này:

doSomethingAsynchronously(^{ 
    someMember_ = 42; 
}); 

... và bạn chắc chắn rằng đối tượng có thành viên mà bạn đang truy cập sẽ còn sống khi khối thực hiện. Bạn không cần phải suy nghĩ về nó. Tương đương trong C++ có vẻ giống như:

// I'm assuming here that `this` derives from std::enable_shared_from_this and 
// is already owned by some shared_ptr. 
auto strongThis = shared_from_this(); 

doSomethingAsynchronously([strongThis, this] { 
    someMember_ = 42; // safe, as the lambda holds a reference to this 
         // via shared_ptr. 
}); 

Ở đây, bạn cần phải nhớ chụp shared_ptr ngoài con trỏ này. Có một số cách ít dễ bị lỗi hơn để đạt được điều này?

Answer 1

Một trong những nguyên tắc sáng lập của C++ là bạn không trả tiền cho những gì bạn không sử dụng. Điều đó có nghĩa là trong trường hợp này, các ngữ cảnh khi lấy shared_ptr đến this là không cần thiết, không nên chịu bất kỳ chi phí đếm tham chiếu nào. Điều này cũng có nghĩa là nó không nên xảy ra tự động ngay cả ví dụ: như một tính năng của enable_shared_from_this, vì bạn có thể muốn truyền một lambda ngắn ngủi đến một thuật toán (for_each, v.v.) trong trường hợp đó lambda không vượt quá phạm vi của nó.

Tôi khuyên bạn nên điều chỉnh lambda-wrapper pattern; trong trường hợp đó nó được sử dụng cho move bắt giữ một đối tượng lớn (How to capture std::unique_ptr "by move" for a lambda in std::for_each), nhưng nó không kém có thể được sử dụng cho chụp chung của this:

template<typename T, typename F> 
class shared_this_lambda { 
    std::shared_ptr<T> t; // just for lifetime 
    F f; 
public: 
    shared_this_lambda(std::shared_ptr<T> t, F f): t(t), f(f) {} 
    template<class... Args> 
    auto operator()(Args &&...args) 
    -> decltype(this->f(std::forward<Args>(args)...)) { 
    return f(std::forward<Args>(args)...); 
    } 
}; 

template<typename T> 
struct enable_shared_this_lambda { 
    static_assert(std::is_base_of<std::enable_shared_from_this<T>, T>::value, 
    "T must inherit enable_shared_from_this<T>"); 
    template<typename F> 
    auto make_shared_this_lambda(F f) -> shared_this_lambda<T, F> { 
    return shared_this_lambda<T, F>(
     static_cast<T *>(this)->shared_from_this(), f); 
    } 
    template<typename F> 
    auto make_shared_this_lambda(F f) const -> shared_this_lambda<const T, F> { 
    return shared_this_lambda<const T, F>(
     static_cast<const T *>(this)->shared_from_this(), f); 
    } 
}; 

Sử dụng bằng cách kế thừa enable_shared_this_lambda ngoài enable_shared_from_this; bạn có thể sau đó một cách rõ ràng yêu cầu rằng bất kỳ lambdas tồn tại lâu dài hãy chia sẻ this:

Answer 2

Boost sử dụng:

auto self(shared_from_this()); 
auto l = [this, self] { do(); }; 

Đề cập ở đây: What's the reason of using auto self(shared_from_this()) variable in lambda function?

Answer 3

Trên thực tế, có một câu trả lời đúng cho vấn đề này . Câu trả lời có cùng hiệu quả ràng buộc với shared_from_this() (giống như khi bạn làm điều đó với boost::asio::io_service). Hãy suy nghĩ về nó; những gì ràng buộc với shared_from_this() làm gì? Nó đơn giản thay thế this. Vì vậy, những gì ngăn cản bạn thay thế this với shared_from_this() hoàn toàn?

Tiếp theo ví dụ của bạn, mà tôi cập nhật để tạo sự khác biệt rõ ràng hơn, thay vì điều này:

auto strongThis = shared_from_this(); 

doSomethingAsynchronously([strongThis, this]() { 
    this->someMember_ = 42; //here, you're using `this`... that's wrong! 
}); 

Làm điều này:

auto strongThis = shared_from_this(); 

doSomethingAsynchronously([strongThis]() //notice, you're not passing `this`! 
{ 
    strongThis->someMember_ = 42;    
}); 

Chi phí duy nhất ở đây là bạn đang gonna phải tiền tố mọi thứ với strongThis->. Nhưng đây là cách có ý nghĩa nhất để làm điều đó.