Come verificare correttamente se std :: function è vuoto in C ++ 11?

Mi chiedevo come controllare correttamente se un std::functionè vuoto. Considera questo esempio:

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

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

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

Questo codice si compila bene in MSVC ma se chiamo doSomething()senza inizializzare eventFuncil codice ovviamente si blocca. È previsto, ma mi chiedevo qual è il valore di eventFunc? Il debugger dice 'empty'. Quindi l'ho risolto usando l'istruzione if semplice:

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

Funziona, ma mi chiedo ancora qual è il valore di non inizializzato std::function? Vorrei scrivere if (eventFunc != nullptr)ma std::function(ovviamente) non è un puntatore.

Perché il puro if funziona? Qual è la magia dietro? Ed è il modo corretto di controllarlo?

Non stai verificando un lambda vuoto, ma se std::functionha un target richiamabile memorizzato in esso. Il controllo è ben definito e funziona per std::function::operator boolquesto consente la conversione implicita boolin contesti in cui sono richiesti valori booleani (come l'espressione condizionale in ifun'istruzione).

Inoltre, la nozione di lambda vuota non ha davvero senso. Dietro le quinte il compilatore converte un'espressione lambda in una definizione struct(o class), con le variabili acquisite memorizzate come membri dati di questa struct. Viene anche definito un operatore di chiamata di funzione pubblica, che è ciò che consente di invocare lambda. Quindi cosa sarebbe un lambda vuoto?

Puoi anche scrivere if(eventFunc != nullptr)se lo desideri, è equivalente al codice che hai nella domanda. std::function definisce operator== e operator!=sovraccarica per il confronto con un file nullptr_t.

Controlla qui http://www.cplusplus.com/reference/functional/function/operator_bool/

Esempio

// 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;
}

Produzione

foo non è richiamabile.

il bar è richiamabile.

(Lasciatemi fornire una risposta chiara.)

Puoi controllare se un std::functionè vuoto con std::function::operator bool.

true: se l'oggetto è richiamabile.
false: altrimenti (l'oggetto è una funzione vuota)

Esempio

#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;
}

Produzione

foo non è vuoto.
il bar è vuoto.