Qu'est-ce qu'une expression lambda en C ++ 11?

Question

Qu'est-ce qu'une expression lambda en C++ 11? Quand pourrais-je en utiliser un? Quelle classe de problèmes résolvent-ils qui n'était pas possible avant leur introduction?

Quelques exemples et cas d'utilisation seraient utiles.

Flexo · Accepted Answer

Le problème

C++ inclut des fonctions génériques utiles comme std::for_each et std::transform, qui peuvent être très pratiques. Malheureusement, ils peuvent également être assez lourds à utiliser, en particulier si le foncteur que vous souhaitez appliquer est unique pour une fonction particulière.

#include <algorithm> #include <vector> namespace { struct f { void operator()(int) { // do something } }; } void func(std::vector<int>& v) { f f; std::for_each(v.begin(), v.end(), f); }

Si vous n'utilisez que f une fois et à cet endroit précis, il semble exagéré d'écrire toute une classe juste pour faire quelque chose de trivial et ponctuel.

En C++ 03, vous pourriez être tenté d’écrire quelque chose comme ceci pour garder le foncteur en local:

void func2(std::vector<int>& v) { struct { void operator()(int) { // do something } } f; std::for_each(v.begin(), v.end(), f); }

cependant, ceci n'est pas autorisé, f ne peut pas être passé à une fonction template en C++ 03.

La nouvelle solution

C++ 11 introduit lambdas qui vous permet d’écrire un foncteur anonyme en ligne pour remplacer le struct f. Pour de petits exemples simples, cela peut être plus clair à lire (cela permet de tout garder au même endroit) et potentiellement plus simple à maintenir, par exemple sous la forme la plus simple:

void func3(std::vector<int>& v) { std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ }); }

Les fonctions Lambda ne sont que du sucre syntaxique pour les foncteurs anonymes.

Types de retour

Dans les cas simples, le type de retour du lambda est déduit pour vous, par exemple:

void func4(std::vector<double>& v) { std::transform(v.begin(), v.end(), v.begin(), [](double d) { return d < 0.00001 ? 0 : d; } ); }

toutefois, lorsque vous commencerez à écrire des lambdas plus complexes, vous rencontrerez rapidement des cas où le type de retour ne peut pas être déduit par le compilateur, par exemple:

void func4(std::vector<double>& v) { std::transform(v.begin(), v.end(), v.begin(), [](double d) { if (d < 0.0001) { return 0; } else { return d; } }); }

Pour résoudre ce problème, vous êtes autorisé à spécifier explicitement un type de retour pour une fonction lambda, en utilisant -> T:

void func4(std::vector<double>& v) { std::transform(v.begin(), v.end(), v.begin(), [](double d) -> double { if (d < 0.0001) { return 0; } else { return d; } }); }

"Capturer" les variables

Jusqu'à présent, nous n'avons rien utilisé d'autre que ce qui a été transmis au lambda, mais nous pouvons également utiliser d'autres variables, au sein du lambda. Si vous souhaitez accéder à d'autres variables, vous pouvez utiliser la clause de capture (le [] de l'expression), qui n'a jusqu'à présent pas été utilisée dans ces exemples, par exemple:

void func5(std::vector<double>& v, const double& epsilon) { std::transform(v.begin(), v.end(), v.begin(), [epsilon](double d) -> double { if (d < epsilon) { return 0; } else { return d; } }); }

Vous pouvez capturer à la fois par référence et par valeur, ce que vous pouvez spécifier en utilisant respectivement & et =:

[&epsilon] capture par référence
[&] capture toutes les variables utilisées dans le lambda par référence
[=] capture toutes les variables utilisées dans le lambda par valeur
[&, epsilon] capture les variables comme avec [&], mais epsilon par valeur
[=, &epsilon] capture les variables comme avec [=], mais epsilon par référence

La operator() générée est const par défaut. L'implication que les captures capturées sera const lorsque vous y accéderez par défaut. Cela a pour effet que chaque appel avec la même entrée produira le même résultat, mais vous pouvez marquer le lambda comme mutable pour demander que la operator() produite ne soit pas const.

pmr · Answer

Qu'est-ce qu'une fonction lambda?

Le concept C++ d’une fonction lambda trouve son origine dans le calcul lambda et la programmation fonctionnelle. Un lambda est une fonction non nommée qui est utile (en programmation réelle et non en théorie) pour de courts extraits de code impossibles à réutiliser et ne méritant pas d'être nommés.

En C++, une fonction lambda est définie comme ceci

[]() { } // barebone lambda

ou dans toute sa gloire

[]() mutable -> T { } // T is the return type, still lacking throw()

[] est la liste de capture, () la liste d'arguments et {} le corps de la fonction.

La liste de capture

La liste de capture définit ce qui doit être disponible à l'extérieur du lambda dans le corps de la fonction et comment. Cela peut être soit:

une valeur: [x]
une référence [& x]
toute variable actuellement dans la portée par référence [&]
identique à 3, mais en valeur [=]

Vous pouvez mélanger n'importe lequel des éléments ci-dessus dans une liste séparée par des virgules [x, &y].

La liste d'arguments

La liste des arguments est la même que dans toute autre fonction C++.

Le corps de fonction

Le code qui sera exécuté lorsque le lambda est appelé.

Type de retour déduction

Si un lambda n'a qu'une seule déclaration de retour, le type de retour peut être omis et possède le type implicite de decltype(return_statement).

Mutable

Si un lambda est marqué comme étant mutable (par exemple, []() mutable { }), il est autorisé à muter les valeurs capturées par valeur.

Cas d'utilisation

La bibliothèque définie par la norme ISO profite énormément des lambdas et augmente la facilité d'utilisation de plusieurs barres, car les utilisateurs n'ont désormais plus à encombrer leur code avec de petits foncteurs accessibles.

C++ 14

En C++ 14, les lambdas ont été étendus par diverses propositions.

Captures Lambda initialisées

Un élément de la liste de capture peut maintenant être initialisé avec =. Cela permet de renommer des variables et de les capturer en les déplaçant. Un exemple tiré de la norme:

int x = 4; auto y = [&r = x, x = x+1]()->int { r += 2; return x+2; }(); // Updates ::x to 6, and initializes y to 7.

et un extrait de Wikipedia montrant comment capturer avec std::move:

auto ptr = std::make_unique<int>(10); // See below for std::make_unique auto lambda = [ptr = std::move(ptr)] {return *ptr;};

Lambdas Générique

Les Lambdas peuvent maintenant être génériques (auto serait équivalent à T ici si T était un argument de modèle de type quelque part dans la portée environnante):

auto lambda = [](auto x, auto y) {return x + y;};

Déduction pour type de retour améliorée

C++ 14 autorise les types de retour déduits pour chaque fonction et ne le limite pas aux fonctions de la forme return expression;. Ceci est également étendu aux lambdas.

nobar · Answer

Les expressions Lambda sont généralement utilisées pour encapsuler des algorithmes afin de pouvoir les transmettre à une autre fonction. Cependant,il est possible d'exécuter un lambda immédiatement après la définition de:

[&](){ ...your code... }(); // immediately executed lambda expression

est fonctionnellement équivalent à

{ ...your code... } // simple code block

Cela fait des expressions lambdaun puissant outil de refactorisation de fonctions complexes. Vous commencez par envelopper une section de code dans une fonction lambda, comme indiqué ci-dessus. Le processus de paramétrage explicite peut ensuite être effectué progressivement avec des tests intermédiaires après chaque étape. Une fois le bloc de code entièrement paramétré (comme le montre la suppression de &), vous pouvez déplacer le code vers un emplacement externe et en faire une fonction normale.

De même, vous pouvez utiliser des expressions lambda pourinitialiser des variables en fonction du résultat d'un algorithme...

int a = []( int b ){ int r=1; while (b>0) r*=b--; return r; }(5); // 5!

Commeun moyen de partitionner la logique de votre programme, vous trouverez peut-être même utile de passer une expression lambda en tant qu'argument à une autre expression lambda ...

[&]( std::function<void()> algorithm ) // wrapper section { ...your wrapper code... algorithm(); ...your wrapper code... } ([&]() // algorithm section { ...your algorithm code... });

Les expressions lambda vous permettent également de créer des fonctions nommées nested , ce qui peut être un moyen pratique d'éviter la duplication de la logique. L'utilisation de lambdas nommés a également tendance à être un peu plus facile pour les yeux (par rapport aux lambdas en ligne anonymes) lors du passage d'une fonction non triviale en tant que paramètre à une autre fonction. Remarque: n'oubliez pas le point-virgule après l'accolade fermante.

auto algorithm = [&]( double x, double m, double b ) -> double { return m*x+b; }; int a=algorithm(1,2,3), b=algorithm(4,5,6);

Si le profilage ultérieur révèle une surcharge d’initialisation importante pour l’objet fonction, vous pouvez choisir de la réécrire en tant que fonction normale.