Wie deklariere ich eine Funktion, die ein Lambda akzeptiert?

Ich habe im Internet viele Tutorials gelesen, in denen erklärt wurde, wie man Lambdas mit der Standardbibliothek verwendet (z. B. std::find), und alle waren sehr interessant, aber ich konnte keine finden, die erklärten, wie ich ein Lambda für meine eigenen Funktionen verwenden kann.

Beispielsweise:

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

    return EXIT_SUCCESS;
}

Wie soll ich deklarieren LambdaTest? Was ist die Art des ersten Arguments? Und wie kann ich dann die an sie übergebene anonyme Funktion - zum Beispiel - "10" als Argument aufrufen?

Da Sie neben Lambdas wahrscheinlich auch Funktionszeiger und Funktionsobjekte akzeptieren möchten, möchten Sie wahrscheinlich Vorlagen verwenden, um Argumente mit einem zu akzeptieren operator(). Dies ist, was die Standardfunktionen wie find tun. Es würde so aussehen:

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

Beachten Sie, dass diese Definition keine c ++ 0x-Funktionen verwendet und daher vollständig abwärtskompatibel ist. Nur der Aufruf der Funktion mit Lambda-Ausdrücken ist c ++ 0x-spezifisch.

Wenn Sie nicht alles vorlegen möchten, können Sie Folgendes tun:

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

Ich möchte dieses einfache, aber selbsterklärende Beispiel beisteuern. Es zeigt, wie "aufrufbare Dinge" (Funktionen, Funktionsobjekte und Lambdas) an eine Funktion oder an ein Objekt übergeben werden.

// 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 ();

} // ()