Anonyme Funktion C++

Dies ist in der Tat eine gute Frage. Lassen Sie uns herausfinden, was Los ist, bevor die Schuld von C++ aber. Denkt daran, wie Lambda-Ausdrücke implementiert sind.

Den meisten einfachen lambda ist, wenn keine Daten erfasst. Wenn das der Fall ist, die zugrunde liegende Art wird eine einfache, schlichte Funktion. Zum Beispiel, ein lambda-Ausdruck wie diesem:

[] (int p0) {}

wird ein äquivalent einer einfachen Funktion:

void foo(int p0)
{
}

Dass tatsächlich perfekt funktioniert, in Fall, dass Sie wollen, dass die lambda zu einem Funktionszeiger. Zum Beispiel:

#include <string>
#include <csignal>
#include <iostream>

int main()
{
    int ret;
    signal(SIGINT, [](int signal) {
            std::cout << "Got signal " << signal << std::endl;
        });
    std::cin >> ret;
    return ret;
}

So weit So gut. Aber jetzt, die Sie zuordnen möchten einige Daten mit Ihrem signal-handler (das ist übrigens der code oben ist Undefiniertes Verhalten wie Sie kann nur ausführen, signal-safe-code, der in einem signal handler). Du willst also ein lambda-Ausdruck wie:

#include <string>
#include <csignal>
#include <iostream>

struct handler_context {
    std::string code;
    std::string desc;
};

int main()
{
    int ret;
    handler_context ctx({ "SIGINT", "Interrupt" });
    signal(SIGINT, [&](int signal) {
            std::cout << "Got signal " << signal
                      << " (" << ctx.code << ": " << ctx.desc
                      << ")\n" << std::flush;
        });
    std::cin >> ret;
    return ret;
}

Vergessen wir für einen moment über einen syntaktischen Zucker von C++ Lambda-Ausdrücke. Es ist kein Geheimnis, dass Sie "nachahmen" lambda auch in C oder assembler. Also wie würde das Aussehen, tatsächlich? "Lambda" im C-Stil könnte so Aussehen (dies ist immer noch C++):

#include <string>
#include <cstdlib>
#include <iostream>

/*
 * This is a context associated with our lambda function.
 * Some dummy variables, for the sake of example.
 */
struct lambda_captures {
    int v0;
    int v1;
};

static int lambda_func(int p0, void *ctx) //<-- This is our lambda "function".
{
    lambda_captures *captures = (lambda_captures *)ctx;
    std::cout << "Got " << p0 << " (ctx: "
              << captures->v0 << ", " << captures->v1
              << ")\n" << std::flush;
    return 0;
}

//Below is an example of API function provided to the user that can
//invoke a callback supplied by the user.
static void some_api_function(int (*callback)(int p, void *data), void *data)
{
    callback(12345, data);
    callback(98765, data);
}

int main()
{
    lambda_captures captures;
    captures.v0 = 1986;
    captures.v1 = 2012;

    some_api_function(lambda_func, (void *)&captures);

    return EXIT_SUCCESS;
}

Oben ist ein C-Stil, C++ neigt zu übergeben "Kontext" als "das", und das ist immer ein implizites erstes argument. Wenn Sie unsere API unterstützt die übergabe von "Daten" als erstes argument, wir könnten pointer to member conversion (PMF) und schreiben etwas wie dieses:

#include <string>
#include <cstdlib>
#include <iostream>

struct some_class {
    int v0;
    int v1;

    int func(int p0)
    {
        std::cout << "Got " << p0 << " (ctx: "
                  << v0 << ", " << v1
                  << ")\n" << std::flush;
        return p0;
    }
};

static void some_api_function(int (*callback)(void *data, int p), void *data)
{
    callback(data, 12345);
    callback(data, 98765);
}

int main()
{
    typedef int (*mpf_type)(void *, int);

    some_class clazz({ 1986, 2012 }); //<- Note a bit of a Java style :-)
    some_api_function((mpf_type)&some_class::func, (void *)&clazz);

    return EXIT_SUCCESS;
}

In den beiden oben beschriebenen Beispielen, beachten Sie, dass die "Daten" immer herum. Dies ist sehr wichtig. Wenn die API, die soll zum aufrufen der callback nicht akzeptieren, ein "void *" - Zeiger übergeben wird, zurück zu Ihrer callback-irgendwie gibt es keine Weise, die Sie zuordnen können, jeder Zusammenhang mit dem Rückruf. Die einzige Ausnahme ist, Globale Daten. Zum Beispiel, diese API ist schlecht:

#include <string>
#include <cstdlib>
#include <iostream>

struct lambda_captures {
    int v0;
    int v1;
};

static int lambda_func(int p0)
{
/*
    //WHERE DO WE GET OUR "lambda_captures" OBJECT FROM????
    lambda_captures *captures = (lambda_captures *)ctx;
    std::cout << "Got " << p0 << " (ctx: "
              << captures->v0 << ", " << captures->v1
              << ")\n" << std::flush;
*/
    return 0;
}

//Below is an example of API function provided to the user that can
//invoke a callback supplied by the user.
static void some_api_function(int (*callback)(int p))
{
    callback(12345);
    callback(98765);
}

int main()
{
    lambda_captures captures;
    captures.v0 = 1986;
    captures.v1 = 2012;

    some_api_function(lambda_func /* How do we pass a context??? */);

    return EXIT_SUCCESS;
}

Dass gesagt wird, eine alte signal-API ist genau so. Der einzige Weg, um das problem zu umgehen ist, um tatsächlich Ihre "Kontext" in einen globalen Gültigkeitsbereich. Dann die signal-handler-Funktion kann auf Sie zugreifen, da die Adresse ist gut bekannt, zum Beispiel:

#include <string>
#include <cstdlib>
#include <iostream>

struct lambda_captures {
    int v0;
    int v1;
};

lambda_captures captures({ 1986, 2012 }); //Whoa-la!!!

static int lambda_func(int p0)
{
    std::cout << "Got " << p0 << " (ctx: "
              << captures.v0 << ", " << captures.v1
              << ")\n" << std::flush;
    return 0;
}

//Below is an example of API function provided to the user that can
//invoke a callback supplied by the user.
static void some_api_function(int (*callback)(int p))
{
    callback(12345);
    callback(98765);
}

int main()
{
    some_api_function(lambda_func);

    return EXIT_SUCCESS;
}

Dies ist, was die Leute zu tun haben. Nicht nur im Fall mit Signale API. Dies gilt für andere Dinge auch. Zum Beispiel interrupt-handler die Verarbeitung. Aber das low-level-Programmierung, wo Sie mit hardware zu tun. Natürlich sind diese Art von API im user-space war nicht die beste Idee. Und ich erwähne es wieder - es ist nur eine kleine Auswahl der Dinge, die Sie tun können, in einem signal-handler. Man kann Sie nur anrufen async-signal-safe-Funktionen.

Natürlich, der alte API ist nicht Weg jederzeit schnell, weil es eigentlich ein POSIX-standard. Dennoch, die Entwickler erkennen das problem und es gibt bessere Möglichkeiten für den Umgang mit Signalen. In Linux, zum Beispiel, können Sie eventfd installieren Sie einen signal-handler, ordnen Sie es mit beliebigen Kontext, und tun, was Sie wollen in der callback-Funktion.

Jedenfalls, kommen wir zurück auf die lambda-Sie spielten mit. Das problem ist nicht mit C++, aber mit Signalen API, die Blätter keine Möglichkeit für Sie, übergeben Sie einen Zusammenhang, außer über eine Globale variable. That being said, es funktioniert mit lambdas zu:

#include <string>
#include <cstdlib>
#include <csignal>
#include <iostream>

struct some_data {
    std::string code;
    std::string desc;
};

static some_data data({ "SIGING", "Interrupt" });

int main()
{
    signal(SIGINT, [](int signal) {
            std::cout << "Got " << signal << " (" << data.code << ", "
                      << data.desc << ")\n" << std::flush;
        });
    return EXIT_SUCCESS;
}

Daher, es ist keine Schande, was C++ ist zu tun hier, da es nicht eine richtige.