Una guida rapida alle espressioni Lambda in C++

I linguaggi di programmazione si evolvono continuamente, anche quelli come C++ che si sono affermati molto tempo fa. Aggiungono funzioni alle librerie standard e apportano altre modifiche per facilitare il lavoro dei programmatori che lavorano in un campo dinamico.

Come parte degli aggiornamenti apportati dall'evoluzione del linguaggio, C++ ha aggiunto il supporto per le espressioni lambda nella sua versione 2011.

Che cos'è esattamente un'espressione lambda e come puoi usarla a tuo vantaggio come programmatore C++?

Che cos'è un'espressione Lambda?

Un'espressione lambda è anche nota come funzione lambda. È un'espressione in linea con la capacità di accettare argomenti, eseguire operazioni e restituire un valore, proprio come una funzione tipica.

Puoi usare un lambda all'interno di un'altra funzione e assegnarlo a una variabile. Le funzioni Lamba sono un modo pratico per definire un oggetto funzione anonimo in un programma. Quasi tutte le lingue supportano lambda, sebbene ogni implementazione differisca dalle altre.

Quali sono le parti di un'espressione Lambda C++?

Le espressioni Lambda sono facili da usare in C++. Puoi scomporre la sintassi di un'espressione lambda in C++ come segue:

[capture_clause](parametri) opzioni { expression_body; }

Per esempio:

int val = 13;
auto sumPlusVal = [val](int un, int b) mutevolenoeccetto ->int { Restituzione val + a + b; };
sommaPiùVal(2, 5); // 20

Dal codice sopra, puoi vedere che un'espressione lambda contiene diverse parti che specificano come funziona. Ecco una rapida panoramica di ciascuno di questi componenti.

1. Clausola di cattura: questa è la prima parte di un'espressione lambda in cui è possibile specificare variabili preesistenti o definirne di nuove da utilizzare nel corpo dell'espressione. Esistono diversi modi per specificare le acquisizioni, ad esempio:

   auto addTwo = [pippo](){ Restituzione pippo + 2; }; // per valore
   auto addThree = [&bar](){ Restituzione barra + 3; }; // come riferimento
   auto addAllVal = [=](){ Restituzione foo + bar; }; // tutto per valore
   auto addAllRef = [&](){ Restituzione foo + bar; }; // tutto per riferimento
   // crea una variabile nella clausola di cattura
   auto createVarInCapture = [pippoBar = foo + bar](){ Restituzione fooBar * 5; };
   // no capture - restituisce un errore perché foo non è accessibile
   auto errorExpression = [](){ Restituzione pippo + 2; };

2. Parametri: Anche questa parte dell'espressione lambda è facoltativa. Contiene i parametri di funzione richiesti da lambda. Questo non è diverso dal solito modo in cui definiresti i parametri di funzione in C++.
3. Opzioni: Puoi anche specificare le opzioni durante la definizione di un'espressione lambda. Alcune opzioni che potresti usare sono: mutevole, eccezione (per esempio noeccetto nel primo codice di esempio), -> tipo_ritorno (per esempio ->int), richiede, attributi, eccetera. Il mutevole l'opzione viene spesso utilizzata perché consente di modificare le acquisizioni all'interno di lambda. Il codice seguente lo dimostra.

   int valore = 10;
   // restituisce un errore: il valore è un const all'interno dell'espressione
   decremento automatico = [valore](){ Restituzione --valore; };
   incremento automatico = [valore]() mutevole { Restituzione ++valore; };
   incremento(); // 11
   

   Sebbene le altre opzioni siano utilizzate raramente, puoi ottenere maggiori informazioni su di esse su cppreference.com pagina su lambda.
4. Corpo espressivo: Questo è il corpo dell'espressione lambda che esegue e restituisce un valore, proprio come farebbe una funzione. Se necessario, puoi dividere il corpo di un'espressione lambda su più di una riga. Tuttavia, è consigliabile mantenerlo il più breve possibile per evitare codice disorganizzato.

Quali sono i vantaggi delle espressioni Lambda?

Ci sono molti vantaggi nell'usare le funzioni lambda nel tuo codice. Oltre a una maggiore velocità di sviluppo ed efficienza, i principali vantaggi che ricevi da lambda sono i seguenti:

• Le espressioni Lambda aiutano a mantenere pulito il codice. Uno dei modi migliori per mantenere il codice semplice e ordinato è utilizzare lambda ove possibile. Questo può essere molto utile per mantenere una struttura del codice leggibile e riutilizzabile.
• Puoi passare lambda ad altre funzioni come parametri. Il Libreria standard C++std:: ordina() metodo fa uso di questo vantaggio. Puoi passare un lambda come uno dei parametri di questo metodo per specificare come la funzione dovrebbe eseguire l'ordinamento. Per esempio:

   std:: vettore<int> arr = {2, 5, 1, 3, 4};
   std:: ordina (arr.begin(), arr.end(), [](int un, int b){ Restituzione a < b; });
  // arr = {1, 2, 3, 4, 5}
  

• Le Lambda sono riutilizzabili. A volte, potresti voler rendere un blocco di codice riutilizzabile nell'ambito di una funzione nel tuo programma senza dover definire una nuova funzione. Le Lambda possono essere molto utili in questi casi. Considera il seguente esempio di un'espressione lambda riutilizzabile:

  #includere <iostream>
  usando spazio dei nomistd;
  intprincipale(){
  // definisce una lambda riutilizzabile
   auto addUp = [](auto a, auto b, auto c) noeccetto {
   cout <<"Ora sommando... "<< un <<", "<< b <<" e "<< c << fine;
  Restituzione a+b+c;
   };
  cout << addUp (22, 33, 44) << fine;
   cout << addUp (stringa("Felice "), corda("Nascita"), corda("giorno")) << fine; 
   cout << addUp(VERO, falso, VERO) << std:: endl; // viene eseguito come numeri (1 e 0)
  }
  

  Questo programma produce il seguente risultato: Questo esempio dimostra quanto sia semplice definire una lambda in modo da poterla utilizzare con qualsiasi tipo.

Utilizzo di Lambda in C++

Ci sono molti altri vantaggi offerti dalle espressioni lambda e li scoprirai man mano che la struttura del tuo programma diventa più complessa. In effetti, i programmatori C++ a volte si riferiscono alle espressioni lambda come chiusure perché sono un ottimo modo per implementare le chiusure nel codice.

Dovresti considerare le espressioni lambda se desideri incorporare concetti C++ moderni nella tua base di codice.