0Pricing
C++ Academy · Leçon

Expressions lambda : capture, mutable et génériques

Écrire des lambdas avec captures, sémantique mutable et paramètres génériques auto

Expressions lambda : capture, mutable et génériques est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Qu’est-ce qu’une lambda ?

Une lambda est un objet fonction anonyme défini en ligne. Utilisez-la là où vous écririez autrement une petite fonction nommée ou une structure dotée de operator().

auto square = [](int x) { return x * x; };
std::cout << square(5);   // 25

Anatomie de la syntaxe

Une lambda comporte quatre parties :

  • [capture] — les variables de la portée environnante à utiliser
  • (parameters) — comme une liste de paramètres de fonction
  • -> return_type — facultatif, souvent déduit
  • { body }

Capture vide

[] signifie « ne rien capturer ». La lambda n’accède qu’aux variables globales et statiques.

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

Capture par valeur

Énumérez les variables dans la clause de capture pour les copier dans la lambda.

int n = 5;
auto times = [n](int x) { return x * n; };
n = 10;
std::cout << times(3);   // 15 (captured n was 5)

Capture par référence

Ajoutez le préfixe & pour capturer par référence. Les modifications effectuées dans la lambda affectent la variable extérieure.

int counter = 0;
auto inc = [&counter]() { ++counter; };
inc(); inc(); inc();
std::cout << counter;   // 3

Captures par défaut&nbsp;: [=] et [&]

Capturez par valeur tout ce qui est utilisé avec [=], ou capturez tout par référence avec [&]. Utilisez ces options avec prudence : soyez explicite lorsque vous le pouvez.

auto f = [=]() { return a + b; };   // copies a, b
auto g = [&]() { return a + b; };   // references a, b

Lambdas modifiables

Par défaut, les captures par valeur sont const dans la lambda. Ajoutez mutable pour pouvoir les modifier — les changements ne concernent que la copie présente dans la lambda.

int n = 5;
auto f = [n]() mutable {
    n += 1;       // OK because of mutable
    return n;
};
f(); f();        // returns 6, then 7
std::cout << n;  // still 5 in outer scope

Déduction du type de retour

Le compilateur déduit le type de retour à partir du corps. Rendez-le explicite lorsque cela est nécessaire.

auto half = [](int x) -> double { return x / 2.0; };

Lambdas génériques (C++14)

Utilisez auto dans la liste des paramètres pour obtenir une lambda générique qui fonctionne avec n’importe quel type.

auto print = [](const auto& x) { std::cout << x << "\n"; };
print(42);          // int
print("hello");    // const char*
print(3.14);       // double

Lambdas comme arguments de fonction

Les algorithmes de STL acceptent les lambdas comme prédicats et transformations.

std::vector<int> v = {5, 2, 8, 1};
std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });

Les lambdas sont des objets fonction

En coulisses, le compilateur génère une classe avec operator(). Vous pouvez stocker les lambdas dans std::function ou auto.

Vérification rapide

Dans une lambda [n](int x) { return x * n; }, pouvez-vous affecter une valeur à n sans rendre la lambda mutable ?

Récapitulatif

Les lambdas sont des objets fonction anonymes définis en ligne. Capturez par valeur ou par référence, utilisez mutable pour modifier les captures par valeur et utilisez des paramètres auto pour les lambdas génériques à partir de C++14.

Questions Fréquemment Posées

La leçon « Expressions lambda : capture, mutable et génériques » est-elle gratuite ?

Oui — le texte complet de « Expressions lambda : capture, mutable et génériques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Expressions lambda : capture, mutable et génériques » ?

Écrire des lambdas avec captures, sémantique mutable et paramètres génériques auto Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Expressions lambda : capture, mutable et génériques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. auto, decltype et déduction de type
  2. for basé sur une plage, nullptr et enum class
  3. Expressions lambda : capture, mutable et génériques
  4. Liaisons structurées et if-init en C++17
← Retour à C++ Academy