En snabbguide till Lambda-uttryck i C++

Programmeringsspråk utvecklas ständigt, även sådana som C++ som etablerade sig för länge sedan. De lägger till funktioner till standardbibliotek och gör andra ändringar för att underlätta arbetet för programmerare som arbetar i ett dynamiskt område.

Som en del av uppdateringarna till följd av språkets utveckling, lade C++ till stöd för lambda-uttryck i sin 2011-version.

Vad är egentligen ett lambda-uttryck, och hur kan du använda det till din fördel som C++-programmerare?

Vad är ett Lambda-uttryck?

Ett lambdauttryck är också känt som en lambdafunktion. Det är ett inline-uttryck med förmågan att acceptera argument, utföra operationer och returnera ett värde, precis som en typisk funktion.

Du kan använda en lambda i en annan funktion och tilldela den till en variabel. Lamba-funktioner är ett praktiskt sätt att definiera ett anonymt funktionsobjekt i ett program. Nästan alla språk stöder lambda, även om varje implementering skiljer sig från de andra.

Vilka är delarna av ett C++ Lambda-uttryck?

Lambda-uttryck är lätta att använda i C++. Du kan bryta ner syntaxen för ett lambda-uttryck i C++ enligt följande:

[capture_clause](parametrar) alternativ { expression_body; }

Till exempel:

int val = 13;
bil sumPlusVal = [val](int en, int b) föränderlignej förutom ->int { lämna tillbaka val + a + b; };
sumPlusVal(2, 5); // 20

Från koden ovan kan du se att ett lambda-uttryck innehåller flera delar som anger hur det fungerar. Här är en snabb översikt över var och en av dessa komponenter.

1. Fånga klausul: Detta är den första delen av ett lambda-uttryck där du kan specificera redan existerande variabler eller definiera nya att använda i uttryckets kropp. Det finns olika sätt att ange fångar, till exempel:

   auto addTwo = [foo](){ lämna tillbaka foo + 2; }; // efter värde
   auto addThree = [&bar](){ lämna tillbaka bar + 3; }; // genom hänvisning
   auto addAllVal = [=](){ lämna tillbaka foo + bar; }; // allt efter värde
   auto addAllRef = [&](){ lämna tillbaka foo + bar; }; // allt genom referens
   // skapa en variabel i capture-satsen
   auto createVarInCapture = [fooBar = foo + bar](){ lämna tillbaka Foo bar * 5; };
   // no capture - returnerar fel eftersom foo inte är tillgängligt
   auto errorExpression = [](){ lämna tillbaka foo + 2; };

2. Parametrar: Denna del av lambdauttrycket är också valfri. Den innehåller de funktionsparametrar som krävs av lambda. Detta skiljer sig inte från det vanliga sättet du skulle definiera funktionsparametrar i C++.
3. Alternativ: Du kan också ange alternativ när du definierar ett lambda-uttryck. Några alternativ du kan använda är: föränderlig, undantag (t.ex nej förutom i den första exempelkoden), ->returtyp (t.ex ->int), kräver, attribut, etc. De föränderlig alternativet används ofta eftersom det gör att fångster kan modifieras inuti lambda. Koden nedan visar detta.

   int värde = 10;
   // returnerar ett fel - värdet är en const inuti uttrycket
   automatisk minskning = [värde](){ lämna tillbaka --värde; };
   automatisk ökning = [värde]() föränderlig { lämna tillbaka ++värde; };
   ökning(); // 11
   

   Även om de andra alternativen sällan används, kan du få mer information om dem på cppreference.com sida om lambdas.
4. Uttryckskropp: Detta är lambda-uttryckets kropp som exekverar och returnerar ett värde, ungefär som en funktion skulle. Om det behövs kan du dela texten i ett lambdauttryck över mer än en rad. Det är dock bästa praxis att hålla den så kort som möjligt för att förhindra oorganiserad kod.

Vilka är fördelarna med Lambda-uttryck?

Det finns många fördelar med att använda lambda-funktioner i din kod. Förutom ökad utvecklingshastighet och effektivitet, är de bästa fördelarna du får med lambdas följande:

• Lambda-uttryck hjälper till att hålla koden ren. Ett av de bästa sätten att hålla din kod enkel och snygg är att använda lambdas där det är möjligt. Detta kan vara till stor hjälp för att upprätthålla en läsbar och återanvändbar kodstruktur.
• Du kan skicka lambdas till andra funktioner som parametrar. De C++ standardbibliotekstd:: sort() metoden utnyttjar denna fördel. Du kan skicka en lambda som en av denna metods parametrar för att specificera hur funktionen ska utföra sorteringen. Till exempel:

   std:: vektor<int> arr = {2, 5, 1, 3, 4};
   std:: sort (arr.begin(), arr.end(), [](int en, int b){ lämna tillbaka a < b; });
  // arr = {1, 2, 3, 4, 5}
  

• Lambdas är återanvändbara. Ibland kanske du vill göra ett kodblock återanvändbart inom ramen för en funktion i ditt program utan att behöva definiera en ny funktion. Lambdas kan vara till stor hjälp i sådana fall. Tänk på följande exempel på ett återanvändbart lambdauttryck:

  #omfatta <iostream>
  använder sig av namnutrymmestd;
  inthuvud(){
  // definiera en återanvändbar lambda
   auto addUp = [](auto a, auto b, auto c) noexcept {
   cout <<"Lägger nu ihop... "<< a <<", "<< b <<" och "<< c << endl;
  lämna tillbaka a + b + c;
   };
  cout << addUp (22, 33, 44) << endl;
   cout << addUp (sträng("Lycklig "), sträng("Födelse"), sträng("dag")) << endl; 
   cout << addUp(Sann, falsk, Sann) << std:: endl; // körs som siffror (1 och 0)
  }
  

  Detta program ger följande resultat: Det här exemplet visar hur enkelt det är att definiera en lambda så att du kan använda den med vilken typ som helst.

Använder lambda i C++

Det finns många andra fördelar som lambda-uttryck erbjuder, och du kommer att upptäcka dem när strukturen i ditt program blir mer komplex. Faktum är att C++-programmerare ibland refererar till lambda-uttryck som stängningar eftersom de är ett så bra sätt att implementera stängningar i kod.

Du bör överväga lambda-uttryck om du vill införliva moderna C++-koncept i din kodbas.