Introduites avec C++11, les fonctions lambda permettent de définir des fonctions anonymes, courtes et locales directement dans le code. Elles rendent certaines opérations plus claires, facilitent l’écriture de code expressif et se prêtent très bien aux techniques de programmation fonctionnelle. Cet article explique la structure, le fonctionnement et les principaux cas d’utilisation des expressions lambda.


1) Qu’est-ce qu’une fonction lambda ?

Une fonction lambda est une fonction anonyme, généralement utilisée pour des opérations simples et rapides. Elle est idéale pour encapsuler une petite logique sans créer une fonction nommée séparée.

Syntaxe de base :


[capture] (parametres) mutable noexcept -> type_retour {
    // corps
};

Forme simplifiée :


[](int x) { return x * 2; };

2) Exemple simple de lambda


auto bonjour = []() {
    cout << "Bonjour !" << endl;
};

bonjour();

3) Lambda avec paramètres


auto addition = [](int a, int b) {
    return a + b;
};

cout << addition(3, 4);

4) Spécifier le type de retour


auto division = [](double a, double b) -> double {
    return a / b;
};

5) Capture des variables

Les lambdas peuvent accéder aux variables présentes dans leur environnement immédiat. Ce mécanisme s’appelle la capture.

Capture par valeur :


int x = 10;
auto f = [x]() {
    cout << x;
};

Capture par référence :


int x = 10;
auto f = [&x]() {
    x += 5;
};

Capturer toutes les variables par valeur :


auto f = [=]() { /* ... */ };

Capturer toutes les variables par référence :


auto f = [&]() { /* ... */ };

6) Utilisation de mutable

Par défaut, une lambda ne peut pas modifier les variables capturées par valeur. Le mot-clé mutable permet de les modifier localement.


int x = 10;
auto f = [x]() mutable {
    x += 5; // autorisé
    return x;
};

7) Lambdas et algorithmes STL

Les lambdas sont particulièrement puissantes lorsqu’elles sont utilisées avec les algorithmes de la STL.

Avec sort :


vector<int> v = {40, 10, 30, 20};

sort(v.begin(), v.end(), [](int a, int b) {
    return a > b; // tri décroissant
});

Avec count_if :


vector<int> nombres = {1, 2, 3, 4, 5, 6};

int c = count_if(nombres.begin(), nombres.end(), [](int x) {
    return x % 2 == 0; // nombres pairs
});

8) Utilisation comme fonction de callback

Les lambdas sont très utiles comme callbacks, notamment dans la programmation événementielle.


void traiter(int x, function<void(int)> callback) {
    callback(x * 2);
}

int main() {
    traiter(5, [](int resultat) {
        cout << "Résultat : " << resultat;
    });
}

9) Lambdas comme objets fonctionnels

Une lambda peut être passée en paramètre, retournée par une fonction ou stockée dans un conteneur.


vector<function<int(int)>> operations;

operations.push_back([](int x) { return x + 1; });
operations.push_back([](int x) { return x * 2; });

10) Avantages des lambdas

  • Code plus court et plus lisible
  • Définition simple de petites fonctions locales
  • Intégration parfaite avec les algorithmes STL
  • Capture flexible (valeur ou référence)
  • Approche plus fonctionnelle dans le code

11) TL;DR

  • Lambda → fonction anonyme en ligne
  • Capture → accès aux variables extérieures
  • mutable → autorise la modification des valeurs capturées
  • Idéal pour sort, count_if et autres algorithmes STL
  • Très adapté aux callbacks et petites fonctions utilitaires
  • Compatible avec Visual Studio 2022, GCC et Clang