0Pricing
C++ Academy · Leçon

Captures de lambda par valeur, par référence et mutable

Choisir soigneusement les clauses de capture et comprendre l’état des lambdas

Captures de lambda par valeur, par référence et mutable est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Récapitulatif des captures

La clause de capture d’une lambda répertorie les variables de la portée environnante qu’elle peut utiliser. Le mode de capture contrôle la manière dont chaque variable est accessible.

Capture par valeur

Les noms indiqués sans & sont copiés lors de la création de la lambda. La lambda possède sa propre copie.

int n = 5;
auto f = [n]() { return n * 2; };
n = 10;
std::cout << f();   // 10 (captured n was 5)

Capture par référence

Les noms précédés de & sont stockés comme des références vers la variable extérieure. Les modifications se propagent dans les deux sens.

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

Capture par défaut : =

[=] capture par valeur tout ce qui est utilisé dans le corps de la lambda. C’est pratique, mais cela peut surprendre — seules les variables référencées sont capturées.

int a = 1, b = 2, c = 3;
auto f = [=]() { return a + c; };   // captures a and c (not b)

Capture par défaut : &

[&] capture par référence tout ce qui est utilisé. Soyez prudent : les références vers des variables locales deviennent invalides si la lambda survit à la portée.

int n = 0;
auto bad = [&]() { return n; };
return bad;        // n dies, lambda dangles

Combiner les modes

Combinez les captures par défaut et les captures spécifiques. Indiquez les variables individuelles pour remplacer le mode par défaut.

int a = 1, b = 2;
auto f = [=, &b]() {     // a by value, b by reference
    return a + b;
};

Lambdas modifiables

Les variables capturées par valeur sont const à l’intérieur de la lambda. Ajoutez mutable pour permettre à la lambda de modifier sa copie capturée.

int n = 5;
auto inc = [n]() mutable {
    ++n;
    return n;
};
inc(); inc();
std::cout << n;   // 5 (outer unchanged)

Captures avec initialisation (C++14)

Capturez le résultat d’une expression sous un nouveau nom. Cela permet la capture par déplacement et l’utilisation de valeurs initiales calculées.

auto ptr = std::make_unique<int>(42);
auto f = [p = std::move(ptr)]() {
    return *p;
};
// ptr is now empty; p owns the int inside the lambda

Capturer this

À l’intérieur d’une méthode membre, [this] capture le pointeur this — tous les membres sont accessibles à l’intérieur de la lambda.

Capturer *this (C++17)

[*this] copie l’objet entier dans la lambda. C’est utile lorsque la lambda survit à l’objet d’origine.

Piège : capture par référence et exécution asynchrone

Ne capturez jamais des variables locales par référence dans une lambda qui s’exécute de manière asynchrone — les variables locales auront probablement disparu avant le déclenchement de la lambda.

// BUG
int local = 42;
std::async([&local]() { use(local); });   // local dies, lambda dangles

Vérification rapide

Quel mode de capture convient pour permettre à une lambda de prendre possession d’un std::unique_ptr provenant de la portée extérieure ?

Récapitulatif

La capture par valeur effectue une copie, tandis que la capture par référence crée un alias. Utilisez prudemment les valeurs par défaut [=] ou [&]. mutable permet de modifier les copies capturées par valeur. Les captures avec initialisation (C++14) permettent la capture par déplacement.

Questions Fréquemment Posées

La leçon « Captures de lambda par valeur, par référence et mutable » est-elle gratuite ?

Oui — le texte complet de « Captures de lambda par valeur, par référence et mutable » 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 « Captures de lambda par valeur, par référence et mutable » ?

Choisir soigneusement les clauses de capture et comprendre l’état des lambdas 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 2 sur 4.

Combien de temps prend la leçon « Captures de lambda par valeur, par référence et mutable » ?

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. Objets fonction et foncteurs
  2. Captures de lambda par valeur, par référence et mutable
  3. Lambdas génériques et fermetures en C++14
  4. std::function : objets appelables à types effacés
← Retour à C++ Academy