En passant de la capture lambda comme pointeur de fonction

Un lambda ne peut être converti en un pointeur de fonction si elle ne rend pas compte de la projet de C++11 section 5.1.2 [expr.prim.lambda] dit (accent mine):

La fermeture pour un type lambda-expression avec pas de lambda-capture a un
public non-virtuel non-explicite const fonction de conversion de pointeur
pour la fonction avoir le même paramètre et les types de retour de la fermeture
type de l'appel de fonction de l'opérateur. La valeur retournée par cette conversion
la fonction doit être l'adresse d'une fonction qui, lorsqu'il est appelé, a
le même effet que l'invocation de la fermeture du type de la fonction d'appel de l'opérateur.

Note, cppreference couvre également, dans leur article sur Lambda fonctions.

Donc l'alternative suivante devrait fonctionner:

typedef bool(*DecisionFn)(int);

Decide greaterThanThree{ []( int x ){ return x > 3; } };

et alors serait-ce:

typedef bool(*DecisionFn)();

Decide greaterThanThree{ [](){ return true ; } };

et comme 5gon12eder points, vous pouvez également utiliser std::function, mais note que std::function est poids lourd, de sorte qu'il n'est pas un coût moins compromis.

OriginalL'auteur Shafik Yaghmour

Je connais un peu cette vieille..

Mais je voulais ajouter:

Expression Lambda (même capturé) peut être traitée comme un pointeur de fonction!

Il est délicat, car une expression Lambda n'est pas une fonction simple. Il est en fait un objet avec un opérateur().

Lorsque vous êtes créatif, vous pouvez utiliser cette!
Penser à une "fonction" de la classe dans le style de std::function.
Si vous enregistrez l'objet!

Vous pouvez également utiliser le pointeur de fonction.

D'utiliser le pointeur de fonction, vous pouvez utiliser les éléments suivants:

int first = 5;
auto lambda = [=](int x, int z) {
    return x + z + first;
};
int(decltype(lambda)::*ptr)(int, int)const = &decltype(lambda)::operator();
std::cout << "test = " << (lambda.*ptr)(2, 3) << std::endl;

De construire une classe qui peut commencer à travailler comme un "std::function" je vais faire court exemple. D'abord vous avez besoin d'un class/struct que peut stocker de l'objet et de la fonction pointeur également vous besoin d'un opérateur() pour l'exécuter:

//OT => Object Type
//RT => Return Type
//A ... => Arguments
template<typename OT, typename RT, typename ... A>
struct lambda_expression {
    OT _object;
    RT(OT::*_function)(A...)const;

    lambda_expression(const OT & object)
        : _object(object), _function(&decltype(_object)::operator()) {}

    RT operator() (A ... args) const {
        return (_object.*_function)(args...);
    }
};

Avec cela, vous pouvez maintenant exécuter capturé, noncaptured lambdas, tout comme vous utilisez la version originale:

auto capture_lambda() {
    int first = 5;
    auto lambda = [=](int x, int z) {
        return x + z + first;
    };
    return lambda_expression<decltype(lambda), int, int, int>(lambda);
}

auto noncapture_lambda() {
    auto lambda = [](int x, int z) {
        return x + z;
    };
    return lambda_expression<decltype(lambda), int, int, int>(lambda);
}

void refcapture_lambda() {
    int test;
    auto lambda = [&](int x, int z) {
        test = x + z;
    };
    lambda_expression<decltype(lambda), void, int, int>f(lambda);
    f(2, 3);

    std::cout << "test value = " << test << std::endl;
}

int main(int argc, char **argv) {
    auto f_capture = capture_lambda();
    auto f_noncapture = noncapture_lambda();

    std::cout << "main test = " << f_capture(2, 3) << std::endl;
    std::cout << "main test = " << f_noncapture(2, 3) << std::endl;

    refcapture_lambda();

    system("PAUSE");
    return 0;
}

Ce code fonctionne avec VS2015
Espérons que cela aide : )

Accueille!

Edit: retiré les aiguilles modèle FP, a supprimé la fonction de pointeur de paramètre, renommé pour lambda_expression

Mise à jour 04.07.17:

template <typename CT, typename ... A> struct function
: public function<decltype(&CT::operator())(A...)> {};

template <typename C> struct function<C> {
private:
    C mObject;

public:
    function(const C & obj)
        : mObject(obj) {}

    template<typename... Args> typename 
    std::result_of<C(Args...)>::type operator()(Args... a) {
        return this->mObject.operator()(a...);
    }

    template<typename... Args> typename 
    std::result_of<const C(Args...)>::type operator()(Args... a) const {
        return this->mObject.operator()(a...);
    }
};

namespace make {
    template<typename C> auto function(const C & obj) {
        return ::function<C>(obj);
    }
}

int main(int argc, char ** argv) {
   auto func = make::function([](int y, int x) { return x*y; });
   std::cout << func(2, 4) << std::endl;
   system("PAUSE");
   return 0;
}

OriginalL'auteur Noxxer

Bien que le modèle de l'approche est intelligente, pour diverses raisons, il est important de rappeler le cycle de vie de la lambda et la capture de variables. Si toute forme de lambda pointeur est va être utilisé et le lambda n'est pas une baisse de la poursuite, alors qu'une copie de [=] lambda doit être utilisé. I. e., même alors, la capture d'un pointeur vers une variable sur la pile est DANGEREUX si la durée de vie de ceux capturés pointeurs de pile (déroulement) est plus courte que la durée de vie de la lambda.

Une solution plus simple pour la capture d'un lambda comme un pointeur est:

auto pLamdba = new std::function<...fn-sig...>([=](...fn-sig...){...});

par exemple, new std::function<void()>([=]() -> void {...}

Rappelez-vous juste pour plus tard delete pLamdba afin de s'assurer que vous n'avez pas de fuite le lambda de la mémoire.
Secret de réaliser ici, c'est que les lambdas peuvent capturer des lambdas (demandez-vous comment cela fonctionne) et aussi que, pour std::function de travailler de façon générique le lambda de la mise en œuvre doit contenir suffisamment d'information interne pour fournir l'accès à la taille de la lambda (et enregistrées) de données (c'est pourquoi l' delete devrait fonctionner [en cours d'exécution des destructeurs de la capture de types]).

OriginalL'auteur smallscript

Un raccourci pour l'utilisation d'un lambda comme C le pointeur de fonction est ceci:

"auto fun = +[](){}"

À l'aide de Curl comme exmample (curl les informations de débogage)

auto callback = +[](CURL* handle, curl_infotype type, char* data, size_t size, void*){ //add code here :-) };
curl_easy_setopt(curlHande, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curlHande,CURLOPT_DEBUGFUNCTION,callback);

OriginalL'auteur janCoffee