Un guide rapide sur les expressions Lambda en C++

Découvrez comment les lambdas peuvent rendre votre code plus efficace et plus facile à maintenir.

Les langages de programmation évoluent continuellement, même ceux comme le C++ qui se sont établis il y a longtemps. Ils ajoutent des fonctions aux bibliothèques standard et apportent d'autres modifications pour faciliter le travail des programmeurs travaillant dans un domaine dynamique.

Dans le cadre des mises à jour apportées par l'évolution du langage, C++ a ajouté la prise en charge des expressions lambda dans sa version 2011.

Qu'est-ce qu'une expression lambda exactement et comment pouvez-vous l'utiliser à votre avantage en tant que programmeur C++ ?

Qu'est-ce qu'une expression Lambda ?

Une expression lambda est également connue sous le nom de fonction lambda. Il s'agit d'une expression en ligne avec la capacité d'accepter des arguments, d'effectuer des opérations et de renvoyer une valeur, tout comme une fonction classique.

Vous pouvez utiliser un lambda dans une autre fonction et l'attribuer à une variable. Les fonctions Lamba sont un moyen pratique de définir un objet fonction anonyme dans un programme. Presque tous les langages prennent en charge les lambdas, bien que chaque implémentation varie des autres.

Quelles sont les parties d’une expression Lambda C++ ?

Les expressions Lambda sont faciles à utiliser en C++. Vous pouvez décomposer la syntaxe d'une expression lambda en C++ comme suit :

[capture_clause](parameters) options { expression_body; }

Par exemple:

int val = 13;
auto sumPlusVal = [val](int a, int b) mutable noexcept ->int { return val + a + b ; };
sumPlusVal(2, 5); // 20

À partir du code ci-dessus, vous pouvez voir qu'une expression lambda contient plusieurs parties qui spécifient son fonctionnement. Voici un bref aperçu de chacun de ces composants.

1. Clause Capture : il s'agit de la première partie d'une expression lambda dans laquelle vous pouvez spécifier des variables préexistantes ou en définir de nouvelles à utiliser dans le corps de l'expression. Il existe différentes manières de spécifier des captures, par exemple :

   auto addTwo = [foo](){ return foo + 2; }; // by value
   auto addThree = [&bar](){ return bar + 3; }; // by reference
   auto addAllVal = [=](){ return foo + bar; }; // all by value
   auto addAllRef = [&](){ return foo + bar; }; // all by reference
    
   // create a variable in capture clause
   auto createVarInCapture = [fooBar = foo + bar](){ return fooBar * 5; };
    
   // no capture - returns error because foo is not accessible
   auto errorExpression = [](){ return foo + 2; };

2. Paramètres : cette partie de l'expression lambda est également facultative. Il contient les paramètres de fonction requis par le lambda. Ce n’est pas différent de la manière habituelle de définir les paramètres de fonction en C++.

3. Options : vous pouvez également spécifier des options lors de la définition d'une expression lambda. Certaines options que vous pouvez utiliser sont : mutable, exception (par exemple nosauf dans le premier exemple de code), ->return_type (par exemple ->int), requiert, attributs, etc. L'option mutable est souvent utilisée car elle permet aux captures d'être modifiables à l'intérieur du lambda. Le code ci-dessous le démontre.

   int value = 10;
    
   // returns an error - value is a const inside the expression
   auto decrement = [value](){ return --value; };
   auto increment = [value]() mutable { return ++value; };
   increment(); // 11
   

4. Corps de l'expression : il s'agit du corps de l'expression lambda qui exécute et renvoie une valeur, un peu comme le ferait une fonction. Si nécessaire, vous pouvez diviser le corps d'une expression lambda sur plusieurs lignes. Cependant, il est préférable de le garder aussi bref que possible pour éviter un code désorganisé.

Quels sont les avantages des expressions Lambda ?

L'utilisation des fonctions lambda dans votre code présente de nombreux avantages. Outre une vitesse et une efficacité de développement accrues, les principaux avantages que vous recevez des lambdas sont les suivants :

• Les expressions Lambda aident à garder le code propre. L'un des meilleurs moyens de garder votre code simple et soigné consiste à utiliser des lambdas lorsque cela est possible. Cela peut être très utile pour maintenir une structure de code lisible et réutilisable.

• Vous pouvez transmettre des lambdas à d'autres fonctions en tant que paramètres. La méthode std::sort() de la bibliothèque standard C++ utilise cet avantage. Vous pouvez passer un lambda comme l'un des paramètres de cette méthode pour spécifier comment la fonction doit effectuer le tri. Par exemple:

    std::vector<int> arr = {2, 5, 1, 3, 4};
    std::sort(arr.begin(), arr.end(), [](int a, int b){ return a < b; });
    // arr = {1, 2, 3, 4, 5}
  

• Les Lambdas sont réutilisables. Parfois, vous souhaiterez peut-être rendre un bloc de code réutilisable dans le cadre d'une fonction de votre programme sans avoir à définir une nouvelle fonction. Les Lambdas peuvent être très utiles dans de tels cas. Prenons l'exemple suivant d'une expression lambda réutilisable :

  #include <iostream>
  using namespace std;
   
  int main() {
      // define a reusable lambda
      auto addUp = [](auto a, auto b, auto c) noexcept {
          cout << "Now adding up... " << a << ", " << b << " and " << c << endl;
          return a + b + c ;
      };
   
      cout << addUp(22, 33, 44) << endl;
      cout << addUp(string("Happy "), string("Birth"), string("day")) << endl; 
      cout << addUp(true, false, true) << std::endl; // executes as numbers(1 and 0)
  }
  

  

Utiliser Lambdas en C++

Les expressions lambda offrent de nombreux autres avantages, et vous les découvrirez à mesure que la structure de votre programme devient plus complexe. En fait, les programmeurs C++ appellent parfois les expressions lambda des fermetures, car elles constituent un excellent moyen d'implémenter des fermetures dans le code.

Vous devriez envisager les expressions lambda si vous souhaitez intégrer des concepts C++ modernes dans votre base de code.