Comment vérifier correctement si std :: function est vide en C ++ 11?

Je me demandais comment vérifier correctement si un std::functionest vide. Prenons cet exemple:

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

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

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

Ce code se compile très bien dans MSVC mais si j'appelle doSomething()sans initialiser eventFuncle code se bloque évidemment. C'est attendu mais je me demandais quelle est la valeur du eventFunc? Le débogueur dit 'empty'. J'ai donc corrigé cela en utilisant une instruction if simple:

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

Cela fonctionne mais je me demande toujours quelle est la valeur de non-initialized std::function? Je voudrais écrire if (eventFunc != nullptr)mais ce std::functionn'est (évidemment) pas un pointeur.

Pourquoi le pur si fonctionne? Quelle est la magie derrière ça? Et, est-ce la bonne façon de le vérifier?

Vous ne vérifiez pas un lambda vide, mais si le std::functioncontient une cible appelable. Le chèque est bien défini et fonctionne grâce àstd::function::operator bool elle permet une conversion implicite booldans des contextes où des valeurs booléennes sont requises (comme l'expression conditionnelle dans une ifinstruction).

De plus, la notion de lambda vide n'a pas vraiment de sens. Dans les coulisses, le compilateur convertit une expression lambda en une struct(ou class) définition, avec les variables que vous capturez stockées en tant que données membres de this struct. Un opérateur d'appel de fonction publique est également défini, ce qui vous permet d'appeler le lambda. Alors, que serait un lambda vide?

Vous pouvez également écrire if(eventFunc != nullptr)si vous le souhaitez, c'est équivalent au code que vous avez dans la question. std::function définit operator== et operator!=surcharge pour comparer avec un nullptr_t.

Vérifiez ici http://www.cplusplus.com/reference/functional/function/operator_bool/

Exemple

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

Production

foo n'est pas appelable.

bar est appelable.

(Permettez-moi de fournir une réponse claire.)

Vous pouvez vérifier si a std::functionest vide avec std::function::operator bool.

true: si l'objet est appelable.
false: sinon (l'objet est une fonction vide)

Exemple

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

Production

foo n'est pas vide.
la barre est vide.