CKTIS / C++
Capture par référence dans une lambda : `[&]`
`[&]` choisit la capture par référence par défaut : la lambda utilise les objets locaux d’origine plutôt que des copies, sans prolonger leur durée de vie.
Version : ISO C++23; implementation support may vary
Syntaxe
[&](parameters) { body }
[&x](parameters) { body }
[&, x](parameters) { body }
[=, &x](parameters) { body }[&] définit la capture par référence comme mécanisme par défaut d’une lambda. La capture implicite concerne les variables admissibles à durée de stockage automatique des portées englobantes dont l’utilisation exige une capture, pas toutes les variables visibles. [&x] capture explicitement x seul par référence ; [&, x] capture x par copie, et [=, &x] capture x par référence avec une capture par copie par défaut. [&, &x] est mal formé. Une variable globale visible comme ::offset n’a pas besoin d’être capturée. [&] existe depuis C++11 ; les règles décrites ici s’appliquent en C++23.
Lorsque les deux lambdas imbriquées capturent total par référence, elles désignent le même objet. Si la lambda externe le capturait par copie, la référence de la lambda interne désignerait la copie dans la fermeture externe. Modifier uniquement la capture rendrait toutefois total += amount invalide : la lambda externe n’est pas déclarée mutable, donc la copie est traitée comme const. mutable n’est pas nécessaire pour modifier un objet non const capturé par référence et ne retire pas la qualification const d’un objet. Ni la capture par référence ni la copie d’une telle fermeture ne prolonge la durée de vie de l’objet. Avant de renvoyer ou de stocker une lambda, assurez-vous que l’objet existera encore lorsqu’elle l’utilisera ; y accéder par une référence pendante entraîne un comportement indéfini. Si une variable de type référence est capturée par référence, c’est la durée de vie de l’objet référencé qui compte.
Dans R& result, & déclare une référence lvalue, pas une capture. result = f() affecte l’objet de l’appelant sans changer l’objet auquel la référence est liée. Un paramètre const int& amount ne permet pas de modifier l’argument par cette référence.
Exemples
#include <iostream>
int offset = 2;
template<class F, class R>
void record(F&& f, R& result) {
result = f();
}
int main() {
int total = 1;
int result = 0;
const int step = 3;
record([&] {
auto add = [&](const int& amount) { total += amount; };
add(step);
return total + ::offset;
}, result);
std::cout << total << ' ' << result << '\n';
}Résultat
4 6
`add(step)` fait passer `total` de `1` à `4`. La lambda externe renvoie `4 + ::offset` et `record` écrit `6` via `result`. Les deux lambdas s’exécutent alors que les objets utilisés sont encore vivants. La ligne de sortie attendue est `4 6`.
Leçons associées
- C++ · Leçon 15 · Avancé · Version : 3
- C++ · Leçon 24 · Avancé · Version : 3