सी ++ लैम्ब्डा कैप्चर बाधा

Question

क्या पैरामीटर के रूप में दिए गए लैम्ब्डा के कैप्चर के प्रकार को बाधित करना संभव है?
उदाहरण के लिए, क्या केवल लैम्बडा लेना संभव है जो संदर्भ द्वारा कुछ भी कैप्चर नहीं करते?

template <typename F> 
void f(const F& lambda) // F must be a lambda that do not capture by ref 
{ 
    ::: 
} 

Answer 1

एमएसल्टर्स नोट करते हैं कि "गैर-कैप्चरिंग लैम्ब्डा को पॉइंटर-टू-फ़ंक्शन में परिवर्तित किया जा सकता है।" इसका क्या मतलब है? लैम्ब्डा ऑब्जेक्ट फ़ंक्शन पैरामीटर प्रकार के लिए पॉइंटर से मेल खाता है।

लैम्ब्डा प्रकार को पॉइंटर-टू-फ़ंक्शन में अनुवाद करना मुश्किल है। एक अनुपालन कार्यान्वयन पर मेरा प्रयास यहां है। यह थोड़ा हैकिश है।

#include <type_traits> 

template< typename fn > 
struct ptmf_to_pf; 

template< typename r, typename c, typename ... a > 
struct ptmf_to_pf< r (c::*) (a ...) const > 
    { typedef r (* type)(a ...); }; 

// Use SFINAE to hide function if lambda is not convertible to function ptr. 
// Only check that the conversion is legal, it never actually occurs. 

template< typename lambda > 
typename std::enable_if< std::is_constructible< 
     typename ptmf_to_pf< decltype(&lambda::operator()) >::type, 
     lambda >::value >::type 
f(lambda arg) { 
    arg("hello "); 
    arg("world\n"); 
} 

#include <iostream> 

int main() { 
int x = 3; 
    f([](char const *s){ std::cout << s; }); // OK 
    f([=](char const *s){ std::cout << s; }); // OK 
    f([=](char const *s){ std::cout << s << x; }); // error 
} 

यह सीधा तर्क के रूप में कार्य संकेत को स्वीकार नहीं करेगा, क्योंकि टेम्पलेट पैरामीटर एक functor को हल करने की जरूरत है। आप इसे ptmf_to_pf के लिए विशेषज्ञता प्रदान करके ऐसा कर सकते हैं जो फ़ंक्शन प्रकारों के लिए पॉइंटर स्वीकार करता है।

इसके अलावा, जैसा कि डेमो दिखाता है, यह लैम्बडा स्वीकार नहीं करेगा जो मूल्य के साथ-साथ संदर्भ द्वारा कुछ भी कैप्चर करता है। प्रतिबंध को इतना विशिष्ट बनाने के लिए सी ++ में कोई रास्ता नहीं है।

Answer 2

शायद तुम लैम्ब्डा अभिव्यक्ति की कैप्चरिंग व्यवहार गलत समझ रहे हैं: एक बंद वस्तु है जैसे एक functor वस्तु से बताया है, इसलिए

struct Fun 
{ 
    Fun (int & a) : n(a) { } 
    int operator()(...) { ... } 
private: 
    int & n; 
}; 

int q; 
Fun f(q); 
f(...); 

बिल्कुल

int q; 
auto f = [&q](...) -> int { ... }; 
f(...); 

रूप में ही है

एक बार बंद ऑब्जेक्ट का निर्माण हो जाने के बाद, सभी कैप्चरिंग और बाध्यकारी समाप्त हो जाती है और ऑब्जेक्ट में हमेशा बंद हो जाती है।

यदि आप ऑब्जेक्ट को call_me(f) जैसे किसी अन्य स्थान पर पास करते हैं, तो प्राप्तकर्ता फ़ंक्शन का फ़ैक्टर या क्लोजर ऑब्जेक्ट के निर्माण से कोई संबंध नहीं है।

Answer 3

अप्रत्यक्ष हैक: केवल गैर-कैप्चरिंग लैम्ब्डा को पॉइंटर-टू-फ़ंक्शन में परिवर्तित किया जा सकता है। बेशक, इसमें F प्रकार भी शामिल हैं जो लैम्ब्डा नहीं हैं।