Exemples d'expressions lambda

Cette rubrique contient des exemples d'utilisation des expressions lambda dans vos programmes.Pour une vue d'ensemble des expressions lambda, consultez Expressions lambda en C++.Pour plus d'informations sur la structure d'une expression lambda, consultez Syntaxe d'expression lambda.

Dans cette section

Exemple : Déclaration des expressions lambda

Exemple : Expressions lambda d'appel

Exemple : Expressions lambda d'imbrication

Exemple : Fonctions lambda d'ordre supérieur

Exemple : À l'aide d'une expression lambda dans une méthode

Exemple : À l'aide de expressions lambda avec des modèles

Exemple : Gestion des exceptions

Exemple : À l'aide de expressions lambda avec les types managés

Exemple : Déclaration des expressions lambda

Description

Étant donné qu'une expression lambda est tapée, vous pouvez l'assigner à une variable d' auto objet ou d' function , comme indiqué dans l'exemple suivant :

Code

// declaring_lambda_expressions1.cpp
#include <functional>

int main()
{
   // Assign the lambda expression that adds two numbers to an auto variable.
   auto f1 = [] (int x, int y) { return x + y; }; 

   // Assign the same lambda expression to a function object.
   function<int (int, int)> f2 = [] (int x, int y) { return x + y; };
}

Commentaires

Pour plus d'informations sur le mot clé d' auto , consultez l' mot clé automatique (type déduction).Pour plus d'informations sur le function class, consultez function Class.

Bien que les expressions lambda sont le plus souvent sont déclarées dans le corps d'une méthode ou fonction, vous pouvez les déclarer partout où vous pouvez initialiser une variable.

Description

Le compilateur Visual C++ lie une expression lambda à ses variables capturées lorsque l'expression est déclarée au lieu de lorsque l'expression est appelée.L'exemple suivant présente une expression lambda qui capture la variable locale i par valeur et la variable locale j par référence.Étant donné que l'expression lambda capture i par valeur, la réassignation d' i ultérieurement dans le programme n'affecte pas le résultat de l'expression.Toutefois, car l'expression lambda capture j par référence, la réassignation d' j affecte le résultat de l'expression.

Code

// declaring_lambda_expressions2.cpp
// compile with: /EHsc
#include <iostream>
#include <functional>

int main()
{
   using namespace std;

   int i = 3;
   int j = 5;

   // The following lambda expression captures i by value and
   // j by reference.
   function<int (void)> f = [i, &j] { return i + j; };

   // Change the values of i and j.
   i = 22;
   j = 44;

   // Call f and print its result.
   cout << f() << endl;
}

Sortie

47

Commentaires

[Dans cette section]

Exemple : Expressions lambda d'appel

Vous pouvez appeler une expression lambda directement ou la passer en tant qu'argument à des algorithmes de (STL) de modèles Standard tels qu' find_if.

Description

L'exemple suivant déclare une expression lambda qui retourne la somme de deux entiers et appelle l'expression immédiatement avec les arguments 5 et 4:

Code

// calling_lambda_expressions1.cpp
// compile with: /EHsc
#include <iostream>

int main()
{
   using namespace std;
   int n = [] (int x, int y) { return x + y; }(5, 4);
   cout << n << endl;
}

Sortie

9

Description

l'exemple suivant passe une expression lambda comme argument à la fonction d' find_if .L'expression lambda retourne true si le paramètre est un nombre pair.

Code

// calling_lambda_expressions2.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>

int main()
{
   using namespace std;

   // Create a list of integers with a few initial elements.
   list<int> numbers;
   numbers.push_back(13);
   numbers.push_back(17);
   numbers.push_back(42);
   numbers.push_back(46);
   numbers.push_back(99);

   // Use the find_if function and a lambda expression to find the 
   // first even number in the list.
   const list<int>::const_iterator result =
      find_if(numbers.begin(), numbers.end(),
         [](int n) { return (n % 2) == 0; });

   // Print the result.
   if (result != numbers.end())
   {
       cout << "The first even number in the list is " 
            << (*result) 
            << "." 
            << endl;
   }
   else
   {
       cout << "The list contains no even numbers." 
            << endl;
   }
}

Sortie

The first even number in the list is 42.

Commentaires

Pour plus d'informations sur la fonction d' find_if , consultez find_if.Pour plus d'informations sur les fonctions STL qui effectuent des algorithmes, consultez <algorithm>.

Description

Vous pouvez appeler une expression lambda assignée à une variable à l'aide de l'opérateur d'appel de fonction, operator().L'exemple suivant assigne une expression lambda à une variable d' auto puis utilise l'opérateur d'appel de fonction pour appeler l'expression lambda :

Code

// calling_lambda_expressions3.cpp
// compile with: /EHsc
#include <iostream>

int main()
{
   using namespace std;

   // Assign the lambda expression that adds two numbers to an 
   // auto variable.
   auto f = [] (int x, int y) { return x + y; };

   // Invoke the function object and print its result.
   cout << f(21, 12) << endl;
}

Sortie

33

Commentaires

Pour plus d'informations sur l'opérateur d'appel de fonction, consultez Appel de fonction (C++).

[Dans cette section]

Exemple : Expressions lambda d'imbrication

Description

Vous pouvez imbriquer une expression lambda dans les autres.L'exemple suivant présente une expression lambda qui contient une autre expression lambda.L'expression lambda interne multiplie son argument par 2 et retourne le résultat.L'expression lambda externe appelle l'expression lambda interne avec son argument et ajoute 3 au résultat.

Code

// nesting_lambda_expressions.cpp
// compile with: /EHsc
#include <iostream>

int main()
{
   using namespace std;

   // The following lambda expression contains a nested lambda
   // expression.
   int m = [](int x) 
      { return [](int y) { return y * 2; }(x) + 3; }(5);

   // Print the result.
   cout << m << endl;
}

Sortie

13

Commentaires

Dans cet exemple, [](int y) { return y * 2; } est l'expression lambda imbriquée.

[Dans cette section]

Exemple : Fonctions lambda d'ordre supérieur

Description

De nombreux langages de programmation prennent en charge le concept d'une fonction d'ordre supérieur. Une fonction d'ordre supérieur est une expression lambda qui prend une autre expression lambda comme argument ou qui retourne une expression lambda.Vous pouvez utiliser la classe d' function pour tenir compte pour l'expression lambda C++ se comporte comme une fonction d'ordre supérieur.L'exemple suivant présente une expression lambda qui retourne un objet d' function et une expression lambda qui prend un objet d' function comme argument :

Code

// higher_order_lambda_expression.cpp
// compile with: /EHsc
#include <iostream>
#include <functional>

int main()
{
   using namespace std;

   // The following code declares a lambda expression that returns 
   // another lambda expression that adds two numbers. 
   // The returned lambda expression captures parameter x by value.
   auto g = [](int x) -> function<int (int)> 
      { return [=](int y) { return x + y; }; };

   // The following code declares a lambda expression that takes another
   // lambda expression as its argument.
   // The lambda expression applies the argument z to the function f
   // and adds 1.
   auto h = [](const function<int (int)>& f, int z) 
      { return f(z) + 1; };

   // Call the lambda expression that is bound to h. 
   auto a = h(g(7), 8);

   // Print the result.
   cout << a << endl;
}

Sortie

16

Commentaires

[Dans cette section]

Exemple : À l'aide d'une expression lambda dans une méthode

Description

Vous pouvez utiliser des expressions lambda dans le corps d'une méthode.L'expression lambda peut accéder à n'importe quelle méthode ou membre auxquelles la méthode englobante peut accéder.Vous pouvez explicitement ou implicitement capturer le pointeur d' this pour fournir l'accès aux méthodes et aux données membres de la classe englobante.

l'exemple suivant montre la classe d' Scale , qui encapsule une valeur d'échelle.La méthode d' ApplyScale utilise une expression lambda pour imprimer le produit de chaque élément en objet d' vector et valeur d'échelle.L'expression lambda capture explicitement le pointeur d' this afin qu'il puisse accéder au membre d' _scale .

// method_lambda_expression.cpp
// compile with: /EHsc
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

class Scale
{
public:
   // The constructor.
   explicit Scale(int scale)
      : _scale(scale)
   {
   }

   // Prints the product of each element in a vector object 
   // and the scale value to the console.
   void ApplyScale(const vector<int>& v) const
   {
      for_each(v.begin(), v.end(), 
         [this](int n) { cout << n * _scale << endl; });
   }

private:
   int _scale;
};

int main()
{
   vector<int> values;
   values.push_back(3);
   values.push_back(6);
   values.push_back(9);

   // Create a Scale object that scales elements by 3 and apply
   // it to the vector object.
   Scale s(3);
   s.ApplyScale(values);
}

Sortie

9
18
27

Commentaires

Vous pouvez utiliser le pointeur d' this explicitement dans une méthode, comme indiqué dans l'exemple suivant :

void ApplyScale(const vector<int>& v) const
{
   for_each(v.begin(), v.end(), 
      [this](int n) { cout << n * this->_scale << endl; });
}

Vous pouvez également capturer le pointeur d' this implicitement, comme indiqué dans l'exemple suivant :

void ApplyScale(const vector<int>& v) const
{
   for_each(v.begin(), v.end(), 
      [=](int n) { cout << n * _scale << endl; });
}

[Dans cette section]

Exemple : À l'aide de expressions lambda avec des modèles

Description

Les expressions lambda sont typées, vous pouvez les utiliser avec des modèles C++.L'exemple suivant illustre les fonctions negate_all et print_all.La fonction d' negate_all s'applique operator- unaire à chaque élément de l'objet d' vector .La fonction d' print_all imprime chaque élément de l'objet d' vector dans la console.

Code

// template_lambda_expression.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

// Negates each element in the vector object.
template <typename T> 
void negate_all(vector<T>& v)
{
    for_each(v.begin(), v.end(), [] (T& n) { n = -n; } );
}

// Prints to the console each element in the vector object.
template <typename T> 
void print_all(const vector<T>& v)
{
   for_each(v.begin(), v.end(), [] (const T& n) { cout << n << endl; } );
}

int main()
{
   // Create a vector of integers with a few initial elements.
   vector<int> v;
   v.push_back(34);
   v.push_back(-43);
   v.push_back(56);

   // Negate each element in the vector.
   negate_all(v);

   // Print each element in the vector.
   print_all(v);
}

Sortie

-34
43
-56

Commentaires

Pour plus d'informations sur les modèles C++, consultez Modèles.

[Dans cette section]

Exemple : Gestion des exceptions

Description

Le corps d'une expression lambda suit les règles pour la gestion des exceptions structurées (SEH) et la gestion des exceptions C++.Vous pouvez gérer une exception levée dans le corps d'une expression lambda ou différer la gestion des exceptions à la portée englobante.L'exemple suivant utilise la fonction d' for_each et une expression lambda pour remplir un objet d' vector de valeurs des autres.Il utilise un bloc d' try/catch pour gérer l'accès non valide au premier vecteur.

Code

// eh_lambda_expression.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

int main()
{
   // Create a vector that contains 3 elements.
   vector<int> elements(3);

   // Create another vector that contains index values.
   vector<int> indices(3);
   indices[0] = 0;
   indices[1] = -1; // This is not a subscript. It will trigger the exception.
   indices[2] = 2;

   // Use the values from the vector of index values to 
   // fill the elements vector. This example uses a 
   // try/catch block to handle invalid access to the 
   // elements vector.
   try
   {
       for_each(indices.begin(), indices.end(), 
           [&] (int index) { elements.at(index) = index; });
   }
   catch (const out_of_range& e) 
   {
       cerr << "Caught '" << e.what() << "'." << endl;
   };
}

Sortie

Caught 'invalid vector<T> subscript'.

Commentaires

Pour plus d'informations sur la gestion des exceptions, consultez Gestion des exceptions dans Visual C++.

[Dans cette section]

Exemple : À l'aide de expressions lambda avec les types managés

Description

La clause de capture d'une expression lambda ne peut pas contenir une variable avec un type managé.Toutefois, vous pouvez passer un argument avec un type managé à la liste de paramètres d'une expression lambda.L'exemple suivant contient une expression lambda qui capture ch variable non managé local par valeur et prend un objet d' System.String comme paramètre :

Code

// managed_lambda_expression.cpp
// compile with: /clr
using namespace System;

int main()
{
    char ch = '!'; // a local unmanaged variable
    
    // The following lambda expression captures local variables
    // by value and takes a managed String object as its parameter.
    [=] (String ^s) 
        { Console::WriteLine(s + Convert::ToChar(ch)); }("Hello");
}

Sortie

Hello!

Commentaires

Vous pouvez également utiliser des expressions lambda avec la bibliothèque STL/CLR.Pour plus d'informations sur STL/CLR, consultez Référence de bibliothèque STL/CLR.

[Dans cette section]

Voir aussi

Référence

Expressions lambda en C++

Syntaxe d'expression lambda

mot clé automatique (type déduction)

function Class

find_if

<algorithm>

Appel de fonction (C++)

Gestion des exceptions dans Visual C++

Autres ressources

Modèles

Référence de bibliothèque STL/CLR