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

Je me demandais comment bien vérifier si une std::function est vide. Considérons 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 je l'appelle doSomething() sans l'initialisation de la eventFunc le code évidemment se bloque. C'est prévu, mais je me demandais quelle est la valeur de la eventFunc? Le débogueur dit 'empty'. J'ai donc résolu à l'aide de simples si la déclaration:

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

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

Pourquoi la pure si les œuvres? Quelle est la magie derrière tout cela? Et, est-ce la bonne façon de le vérifier?

  • Notez que eventFunc n'est pas un lambda, c'est un std::function. Vous pouvez stocker des lambdas dans std::functions, mais ils ne sont pas la même chose.
  • Vous avez raison, j'ai changé le titre pour éviter toute confusion. Merci.
InformationsquelleAutor NightElfik | 2014-02-16
  1. 91

    Vous n'êtes pas vérifiant qu'un vide lambda, mais si le std::function a un callable cible est stockée. La case est bien définie et fonctionne en raison de std::fonction: fonction:opérateur booléen qui permet la conversion implicite en bool dans des contextes où les valeurs booléennes sont nécessaires (telles que l'expression conditionnelle dans un if déclaration).

    En outre, la notion de vide lambda n'a pas vraiment de sens. Derrière les coulisses, le compilateur convertit une expression lambda dans un struct (ou class) de la définition, avec les variables de la capture des données enregistrées par les membres de ce struct. Une fonction publique à l'appel de l'opérateur est également définie, qui est ce qui permet d'invoquer le lambda. Donc, ce serait un vide lambda être?

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

    • Ne pas == nullptr faire la même chose, si? Il semble qu'il y est censé être une surcharge pour le == opérateur qui provoque un "vide", std::function de comparer true contre nullptr: cplusplus.com/reference/functional/function/operators
    • Oui, la comparant à nullptr sera trop de travail, if(eventFunc != nullptr) est équivalent à if(eventFunc) dans la question ci-dessus.
    • Techniquement, std::function::operator bool ne permet pas de conversion implicite en bool. Il est marqué explicit après tout, mais la série fait une exception pour certaines constructions de langage que s'attendre à des expressions booléennes, en l'appelant "contextuellement converti bool." Vous pouvez trouver le fragment de standardese et une explication ici: chris-sharpe.blogspot.com/2013/07/...
    • Yep, je suis conscient que le booléen opérateur de conversion est explicit, c'est pourquoi j'ai fait très attention à l'état de permet la conversion implicite de bool dans des contextes où les valeurs booléennes sont requis. C'est exactement ce qui se passe dans le code en question.
    • Le point que j'essaie de faire, c'est que la norme attribue un sens très précis à la notion de "conversion implicite", et il est très différent de "contextuel de la conversion en booléen", ce qui a un sens très précis. Il n'est pas "Est-un" de la relation ici. Je comprends que les débutants n'ont pas besoin de connaître la différence entre l'implicite/explicite/contextuelle de conversion tout de suite, mais c'est mieux d'apprendre les bons mots inconsciemment, que d'avoir à briser les vieilles habitudes plus tard.
    InformationsquelleAutor Praetorian
  2. 19

    Vérifier 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;
}

    Sortie

    foo n'est pas appelable.

    bar est appelable.

    • Je pense que cette réponse serait plus clair sans les swap(). Je pensais que la sortie était en arrière jusqu'à ce que j'ai réalisé il.
    InformationsquelleAutor Dawid Drozd