Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Capture par copie dans les lambdas C++

Capturez un seuil par valeur pour que le prédicat continue de l’utiliser même si la variable d’origine change.

Version : ISO C++23; implementation support may vary

Syntaxe

[cost](int price) { return price <= cost; }  // explicit capture by copy
[=](int price) { return price <= cost; }     // implicit capture by copy of an eligible local
[&cost](int price) { return price <= cost; } // explicit capture by reference
[cost]() mutable { return ++cost; }         // modifies the stored copy of a non-const int
[limit = cost](int price) { return price <= limit; } // init-capture (C++14)

L’évaluation d’une expression lambda crée un objet de fermeture. [cost] initialise directement un membre de cet objet à partir de la valeur courante de la variable locale cost, au moment de la création et non à l’appel. [=] sélectionne la capture par copie pour les variables locales capturées implicitement, sans copier toutes les variables de la portée. [limit = cost] est une capture avec initialiseur (depuis C++14) qui stocke la valeur sous le nouveau nom limit.

Pour une lambda non statique sans paramètre d’objet explicite, operator() est const par défaut. mutable permet au corps de modifier une copie stockée non const, pas l’original. Il ne supprime pas le qualificatif const d’un membre et ne peut pas être combiné avec un paramètre d’objet explicite (C++23). Une lambda déclarée static (depuis C++23) a en revanche un opérateur d’appel statique, sans qualificatif const.

[&cost] donne accès à l’original et reflète ses modifications ultérieures. Cette capture ne prolonge pas sa durée de vie ; y accéder après sa fin peut provoquer un comportement indéfini. Un int stocké dans la fermeture peut survivre à l’original, mais copier un pointeur brut ne copie pas l’objet pointé et ne prolonge pas sa durée de vie.

Pour un vecteur const, std::vector::begin et std::vector::end renvoient un const_iterator. Ils délimitent une plage semi-ouverte, du début jusqu’à la position après le dernier élément, qu’il ne faut pas déréférencer. std::count_if compte les éléments pour lesquels le prédicat renvoie true. Ici, price <= cost compare au seuil stocké sans modifier les éléments ni aucun état.

Utilisez #include directement pour <algorithm>, <iostream> et <vector> au lieu de dépendre d’inclusions transitives. L’opérateur d’insertion << envoie le résultat du comptage et '\n' à std::cout. Le saut de ligne seul ne demande pas de vider le tampon du flux ; std::endl ajoute un saut de ligne et appelle flush().

Exemples

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    const std::vector<int> prices{4, 7, 10, 12};
    int cost = 10;
    const auto within_budget = [cost](int price) {
        return price <= cost;
    };

    cost = 4;
    std::cout << std::count_if(prices.begin(), prices.end(), within_budget) << '\n';
}

Résultat

3

Après `cost = 4`, le prédicat utilise toujours la valeur `10` stockée : `4`, `7` et `10` satisfont la condition. Le programme affiche `3` ; avec `[&cost]`, il afficherait `1`.

Leçons associées

  • C++ · Leçon 40 · Avancé · Version : 3

Sources