सी ++ 11 लैम्ब्डा

Question

सी ++ 11 में पैरामीटर/स्टोरेज प्रकार, आप एक फ़ंक्शन घोषित करते हैं जो लैम्बडा अभिव्यक्ति को तर्क के रूप में लेता है? मुझे लैम्ब्डा घोषित करने या उन्हें टेम्पलेट पैरामीटर के रूप में लेने के लिए ऑनलाइन संसाधनों का बहुत कुछ मिल सकता है, लेकिन मैं वास्तव में क्या करना चाहता हूं, यह लैम्बडास को कॉलबैक हैंडलर को आसानी से घोषित करने में सक्षम है, जो बंद होने से संभव हो गया है जावास्क्रिप्ट में और उद्देश्य-सी में कोड ब्लॉक।

class MyCallback { 
public: 
    virtual ~MyCallback() {} 
    virtual void operator(int arg) = 0; 
}; 

void registerCallback(const std::shared_ptr<MyCallback> &); 

void foo(void) { 
    int a, b, c; 
    class LocalCallback: public MyCallback { 
     int a, b, c; 
    public: 
     LocalCallback(int a, int b, int c): a(a), b(b), c(c) {} 
     void operator(int arg) { std::cout << (a+b+c)*arg << std::endl; } 
    }; 
    registerCallback(std::shared_ptr<MyCallback>(new LocalCallback(a,b,c))); 
} 

जिसमें सरलीकृत किया जाएगा:

void registerCallback(/* WHAT GOES HERE? */); 

void foo(void) { 
    int a, b, c; 
    registerCallback([=](int arg){std::cout << (a+b+c)*arg << std::endl; }) 
} 

तो, जहाँ मैं /* WHAT GOES HERE? */ जो लिखा है उसे हो जाता है

अनिवार्य रूप से, क्लासिक सी ++ का निर्माण मैं एक लैम्ब्डा के साथ बदलना चाहते हैं कुछ की तरह है ?

संपादित करें: यह तुरंत कॉल करने और कॉल करने के बजाए कॉलबैक को स्टोर करने के उद्देश्य से वापस कॉल करने के उद्देश्य से है।

Answer 1

आमतौर पर const std::function<void(int)> & या std::function<void(int)>।

मुझे यकीन नहीं है कि std::function पर निर्णय क्या है या नहीं, इसके आधार पर निर्णय क्या है। शायद मूल्य से ठीक है, खासकर जब से आप स्टोर करने के लिए इसे कॉपी करने जा रहे हैं।

यदि यह सभी वाक्यविन्यास के बीच में स्पष्ट नहीं है, तो void(int) एक फ़ंक्शन प्रकार है, और std::function<T> का अर्थ है, "टाइप टी के कार्यों के समान हस्ताक्षर वाला एक फ़ैक्टर"।

लैम्बडास में अज्ञात प्रकार हैं। कोई रास्ता नहीं है अपने लैम्ब्डा अभिव्यक्ति के प्रकार के नाम के लिए नहीं है, और एक ही हस्ताक्षर के साथ अलग अलग लैम्ब्डा भाव के प्रकार से अलग हैं:

auto foo = [=](int arg){std::cout << (a+b+c)*arg << std::endl; }; 
auto bar = [=](int arg){std::cout << (a+b+c)*arg << std::endl; }; 
// foo and bar have different types, accessible as decltype(foo), decltype(bar) 

इसलिए

std::function, जो मूल रूप से इकट्ठा करने के लिए एक प्रकार-मिटाकर आवरण है के लिए की जरूरत एक ही प्रकार के समान हस्ताक्षर के साथ एक साथ विभिन्न मज़ेदार। यह टेम्पलेट्स के साथ स्थैतिक बहुरूपता के बीच का पुल है, और यदि आप कॉलबैक पंजीकृत करना चाहते हैं तो गतिशील बहुरूपता की आवश्यकता है, इसे बाद में स्टोर करें, और उसके बाद मूल प्रकार को "याद" किए बिना कॉल करें।

Answer 2

void registerCallback(const std::function<void(int)>& callback); 

Answer 3

फ़ंक्शन टेम्पलेट का उपयोग करने पर विचार करें। (नहीं भी महत्वपूर्ण तुम भी Functor functor के रूप में पैरामीटर स्वीकार कर सकते हैं, कि।)

template<typename Functor> 
void registerCallback(Functor&& functor); 

: जब अधिक भार इस तरह के बेहतर व्यवहार के रूप में करने के लिए अच्छे कारण, की एक किस्म के होते हैं (std::function पर अधिक भार दर्दनाक है) अगर कोड को उदाहरण की आवश्यकता है functor बाद में पर स्टोर करें जो std::function के अंदर होने की संभावना है। जहां आप std::function से बचना चाहते हैं फ़ंक्शन पैरामीटर में हैं।