Expresii lambda

Expresiile lambda reprezintă o sintaxă mai scurtă și compactă pentru definirea obiectelor-funcții. Sintaxa formală a unei expresii lambda este:

[] (parametri) { acțiuni }

Expresia lambda începe cu paranteze pătrate. Apoi, ca la o funcție obișnuită, între paranteze rotunde urmează lista de parametri — tipurile și numele lor. De asemenea, începând cu standardul C++14, pentru parametri pot fi specificate valori implicite. După lista de parametri, între acolade sunt plasate acțiunile care se execută în cadrul expresiei lambda.

De exemplu, o expresie lambda foarte simplă:

[]() { std::cout << "Hello" << std::endl; }

Aici expresia lambda nu are parametri, deci lista este goală. În interiorul expresiei se afișează pe consolă șirul "Hello".

De fiecare dată când compilatorul întâlnește o expresie lambda, el generează un tip de clasă nou, care reprezintă obiectul-funcție. În exemplul de mai sus, clasa generată ar putea arăta astfel, simplificat:

class __Lambda1234
{
public:
    auto operator()() const { std::cout << "Hello" << std::endl; }
};

Această clasă are un nume generat arbitrar, dar unic. Acțiunile lambda sunt definite prin operatorul (), iar tipul returnat este dedus automat cu auto. Astfel, compilatorul deduce tipul returnat — poate fi void sau alt tip.

Pentru lambda fără parametri puteți omite lista goală de parametri (). Astfel, o expresie lambda de forma []() { ... } poate fi scrisă și ca:

[]{ std::cout << "Hello" << std::endl; }

Apelul expresiei lambda

Putem apela direct o expresie lambda imediat după definire, specificând între paranteze rotunde valorile pentru parametri:

#include <iostream>
  
int main()
{
    [](){std::cout << "Hello" << std::endl;} ();
    // sau
    []{std::cout << "Hello" << std::endl;} ();
}

Pentru că expresiile lambda nu au parametri, pentru apel se folosesc paranteze goale () imediat după definire.

Aceasta va executa acțiunile lambda și va afișa pe consolă:

Hello

Lambda denumite

Expresia lambda poate fi stocată într-o variabilă:

#include <iostream>
  
int main()
{
    // variabila hello reprezintă expresia lambda
    auto hello { [](){std::cout << "Hello" << std::endl;} };
 
    // apelăm lambda prin variabilă
    hello();    // Hello
    hello();    // Hello
}

Variabila hello stochează expresia lambda, iar tipul este dedus automat cu auto.

Apoi putem apela expresia ca pe o funcție:

hello();

Parametri

Să definim acum o expresie lambda cu doi parametri:

#include <iostream>
  
int main()
{
    auto print { [](const std::string& text){std::cout << text << std::endl;} };
 
    // apelăm lambda
    print("Hello World!");          // Hello World!
    print("Good bye, World...");    // Good bye, World...
}

Expresia lambda primește un parametru de tip const std::string&, adică un șir care este afișat pe consolă. Această lambda este stocată în variabila print.

Apelăm print ca pe o funcție obișnuită, trecând un șir ca argument:

print("Hello World!");          // Hello World!
print("Good bye, World...");    // Good bye, World...

De asemenea, putem apela imediat o expresie lambda la definire, oferind un șir ca parametru:

[](const std::string& text){std::cout << text << std::endl;} ("Hello");