एक लंबर को स्वीकार करने वाले फ़ंक्शन की घोषणा कैसे करें?

Question 1

मैंने इंटरनेट पर कई ट्यूटोरियल पढ़े, जिसमें बताया गया था कि मानक पुस्तकालय (जैसे जैसे std::find) के साथ लैम्ब्डा का उपयोग कैसे किया जाता है , और वे सभी बहुत दिलचस्प थे, लेकिन मुझे ऐसा कोई भी नहीं मिला, जिसमें बताया गया कि मैं अपने कार्यों के लिए लैम्बडा का उपयोग कैसे कर सकता हूं।

उदाहरण के लिए:

int main()
{
    int test = 5;
    LambdaTest([&](int a) { test += a; });

    return EXIT_SUCCESS;
}

मुझे कैसे घोषित करना चाहिए LambdaTest? इसके पहले तर्क का प्रकार क्या है? और फिर, मैं इसे पास करने वाले अनाम फ़ंक्शन को कैसे कह सकता हूं - उदाहरण के लिए - "10" इसके तर्क के रूप में?

Question 2

यह देखते हुए कि आप शायद लंबोदर के अलावा फ़ंक्शन पॉइंटर्स और फ़ंक्शन ऑब्जेक्ट्स को भी स्वीकार करना चाहते हैं, आप शायद किसी भी तर्क को स्वीकार करने के लिए टेम्प्लेट का उपयोग करना चाहेंगे operator()। यह वही है जो एसटीडी-फ़ंक्शंस खोज करते हैं। यह इस तरह दिखेगा:

template<typename Func>
void LambdaTest(Func f) {
    f(10);
}

ध्यान दें कि यह परिभाषा किसी भी c ++ 0x सुविधाओं का उपयोग नहीं करती है, इसलिए यह पूरी तरह से पीछे की ओर संगत है। यह lambda अभिव्यक्तियों का उपयोग करके फ़ंक्शन के लिए केवल कॉल है जो c ++ 0x-specific है।

Question 3

यदि आप सब कुछ टेम्पलेट नहीं करना चाहते हैं, तो आप निम्न कार्य कर सकते हैं:

#include<functional> 

void LambdaTest (const std::function <void (int)>& f)
{
    ...
}

Question 4

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

// g++ -std=c++11 thisFile.cpp

#include <iostream>
#include <thread>

using namespace std;

// -----------------------------------------------------------------
class Box {
public:
  function<void(string)> theFunction; 
  bool funValid;

  Box () : funValid (false) { }

  void setFun (function<void(string)> f) {
    theFunction = f;
    funValid = true;
  }

  void callIt () {
    if ( ! funValid ) return;
    theFunction (" hello from Box ");
  }
}; // class

// -----------------------------------------------------------------
class FunClass {
public:
  string msg;
  FunClass (string m) :  msg (m) { }
  void operator() (string s) {
    cout << msg <<  s << endl; 
  }
};

// -----------------------------------------------------------------
void f (string s) {
  cout << s << endl;
} // ()

// -----------------------------------------------------------------
void call_it ( void (*pf) (string) ) {
  pf( "call_it: hello");
} // ()

// -----------------------------------------------------------------
void call_it1 ( function<void(string)> pf ) {
  pf( "call_it1: hello");
} // ()

// -----------------------------------------------------------------
int main() {

  int a = 1234;

  FunClass fc ( " christmas ");

  f("hello");

  call_it ( f );

  call_it1 ( f );

  // conversion ERROR: call_it ( [&] (string s) -> void { cout << s << a << endl; } );

  call_it1 ( [&] (string s) -> void { cout << s << a << endl; } );

  Box ca;

  ca.callIt ();

  ca.setFun (f);

  ca.callIt ();

  ca.setFun ( [&] (string s) -> void { cout << s << a << endl; } );

  ca.callIt ();

  ca.setFun (fc);

  ca.callIt ();

} // ()