सी ++ 11 लैम्बडास को असीमित रूप से उपयोग करके, सुरक्षित रूप से

Question

मैं एक उद्देश्य-सी पृष्ठभूमि से सी ++ 11 पर आया हूं, और एक चीज जिसके साथ मैं आने के लिए संघर्ष कर रहा हूं वह सी ++ 11 के विभिन्न कैप्चरिंग अर्थशास्त्र है लैम्बडा बनाम उद्देश्य-सी "ब्लॉक"। (तुलना के लिए here देखें)।

उद्देश्य-सी में, सी ++, self/this पॉइंटर को निश्चित रूप से कैप्चर किया गया है यदि आप किसी सदस्य चर का संदर्भ लेते हैं। लेकिन क्योंकि ऑब्जेक्टिव-सी में सभी वस्तुओं को प्रभावी ढंग से "साझा संकेत", सी ++ शब्दावली का उपयोग करने के लिए हैं, तो आप ऐसा कर सकते हैं:

doSomethingAsynchronously(^{ 
    someMember_ = 42; 
}); 

... और आप की गारंटी कर रहे हैं कि वस्तु जिसका सदस्य आप तक पहुँच रहे हैं ब्लॉक निष्पादित होने पर जीवित रहेगा। आपको इसके बारे में सोचना नहीं है।

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

यहाँ आप इस सूचक के अलावा shared_ptr कब्जा करने के लिए याद करने की आवश्यकता: सी ++ में बराबर की तरह कुछ हो रहा है। क्या इसे प्राप्त करने में कुछ कम त्रुटि-प्रवण तरीका है?

Answer 1

सी ++ के संस्थापक सिद्धांतों में से एक यह है कि आप जो भी उपयोग नहीं करते हैं उसके लिए आप भुगतान नहीं करते हैं। इसका मतलब है कि इस मामले में संदर्भ है कि shared_ptr से this पर अनावश्यक है किसी भी संदर्भ गिनती ओवरहेड नहीं लेना चाहिए। इसका यह भी अर्थ है कि यह स्वचालित रूप से भी नहीं होना चाहिए उदा। enable_shared_from_this की एक विशेषता के रूप में, क्योंकि आप एक अल्गोरिदम (for_each इत्यादि) में एक अल्पकालिक लैम्ब्डा पास करना चाहते हैं, इस मामले में लैम्ब्डा अपने दायरे को पार नहीं कर सकता है।

मैं lambda-wrapper pattern को अपनाने का सुझाव देना चाहता हूं; उस मामले में यह एक बड़ी वस्तु (How to capture std::unique_ptr "by move" for a lambda in std::for_each) की move कब्जा के लिए इस्तेमाल किया है, लेकिन यह भी उतना ही 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); 
    } 
}; 

enable_shared_from_this के अलावा enable_shared_this_lambda इनहेरिट द्वारा उपयोग; आप तो स्पष्ट रूप से अनुरोध कर सकते हैं कि किसी भी लंबे समय तक रहा lambdas ले एक साझा this:

Answer 2

बूस्ट का उपयोग करता है:

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

यहाँ उल्लेख किया: What's the reason of using auto self(shared_from_this()) variable in lambda function?

Answer 3

वास्तव में, इस समस्या का एक सही जवाब है । उत्तर shared_from_this() के साथ बाध्यकारी का सटीक प्रभाव है (जैसे कि आप इसे boost::asio::io_service के साथ करते हैं)। इसके बारे में सोचो; shared_from_this() के साथ बाध्यकारी क्या करता है? यह this को बदल देता है। तो shared_from_this() के साथ this को बदलने से आपको क्या रोकता है?

अपने उदाहरण है, जो मैं, अंतर स्पष्ट करने के लिए अद्यतन के बजाय इस बात का बाद:

auto strongThis = shared_from_this(); 

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

यह करें:

auto strongThis = shared_from_this(); 

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

केवल लागत यहाँ है कि आप करने के लिए है करने वाले हैं है strongThis-> के साथ सबकुछ उपसर्ग करें। लेकिन यह करने का यह सबसे सार्थक तरीका है।