Wie kann ich richtig überprüfen, ob die Funktion std :: in C ++ 11 leer ist?

Ich habe mich gefragt, wie ich richtig prüfen soll, ob ein std::functionleer ist. Betrachten Sie dieses Beispiel:

class Test {
    std::function<void(int a)> eventFunc;

    void registerEvent(std::function<void(int a)> e) {
        eventFunc = e;
    }

    void doSomething() {
        ...
        eventFunc(42);
    }
};

Dieser Code wird in MSVC einwandfrei kompiliert, aber wenn ich doSomething()ohne Initialisierung aufrufe, eventFuncstürzt der Code offensichtlich ab. Das wird erwartet, aber ich habe mich gefragt, welchen Wert das hat eventFunc. Der Debugger sagt 'empty'. Also habe ich das mit einer einfachen if-Anweisung behoben:

   void doSomething() {
        ...
        if (eventFunc) {
            eventFunc(42);
        }
   }

Das funktioniert, aber ich frage mich immer noch, welchen Wert nicht initialisiert hat std::function. Ich würde gerne schreiben if (eventFunc != nullptr), std::functionist aber (offensichtlich) kein Zeiger.

Warum funktioniert das reine wenn? Was ist die Magie dahinter? Und ist es die richtige Art, es zu überprüfen?

Sie suchen nicht nach einem leeren Lambda, sondern danach, ob in dem std::functionein aufrufbares Ziel gespeichert ist. Die Prüfung ist genau definiert und funktioniert, std::function::operator boolwodurch eine implizite Konvertierung boolin Kontexte ermöglicht wird, in denen boolesche Werte erforderlich sind (z. B. der bedingte Ausdruck in einer ifAnweisung).

Außerdem macht die Vorstellung eines leeren Lambda keinen Sinn. Hinter den Kulissen konvertiert der Compiler einen Lambda-Ausdruck in eine struct(oder class) Definition, wobei die von Ihnen erfassten Variablen als Datenelemente gespeichert werden struct. Es wird auch ein öffentlicher Funktionsaufrufoperator definiert, mit dem Sie das Lambda aufrufen können. Was wäre ein leeres Lambda?

Sie können auch schreiben, if(eventFunc != nullptr)wenn Sie möchten. Dies entspricht dem Code, den Sie in der Frage haben. std::function definiert operator== und operator!=überlastet zum Vergleich mit a nullptr_t.

Überprüfen Sie hier http://www.cplusplus.com/reference/functional/function/operator_bool/

Beispiel

// function::operator bool example
#include <iostream>     // std::cout
#include <functional>   // std::function, std::plus

int main () {
  std::function<int(int,int)> foo,bar;
  foo = std::plus<int>();

  foo.swap(bar);

  std::cout << "foo is " << (foo ? "callable" : "not callable") << ".\n";
  std::cout << "bar is " << (bar ? "callable" : "not callable") << ".\n";

  return 0;
}

Ausgabe

foo ist nicht aufrufbar.

Bar ist aufrufbar.

(Lassen Sie mich eine klare Antwort geben.)

Sie können überprüfen, ob a std::functionmit leer ist std::function::operator bool.

true: Wenn das Objekt aufrufbar ist.
false: andernfalls (das Objekt ist eine leere Funktion)

Beispiel

#include <iostream>
#include <functional>

int main ()
{
    std::function<int(int,int)> foo = std::plus<int>();//assigned: not empty
    std::function<int(int,int)> bar;//not assigned: empty

    std::cout << "foo is " << (foo ? "not empty" : "empty") << ".\n";
    std::cout << "bar is " << (bar ? "not empty" : "empty") << ".\n";

    return 0;
}

Ausgabe

foo ist nicht leer.
Bar ist leer.