Fonctions Lambda et cas d’utilisation en C++
Apprenez les fonctions Lambda en C++, les captures et leurs cas d’utilisation avec des exemples pratiques.
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