CKTIS / C++
Lambda-capture via referentie: `[&]`
`[&]` stelt capture via referentie in als standaard: de lambda gebruikt de oorspronkelijke lokale objecten in plaats van kopieën, maar verlengt hun levensduur niet.
Versie: ISO C++23; implementation support may vary
Syntax
[&](parameters) { body }
[&x](parameters) { body }
[&, x](parameters) { body }
[=, &x](parameters) { body }[&] stelt capture via referentie in als standaard voor een lambda. Alleen geschikte variabelen met automatische opslagduur uit omsluitende scopes worden impliciet vastgelegd als hun gebruik capture vereist, niet alle zichtbare variabelen. [&x] legt expliciet alleen x via referentie vast; [&, x] legt x als kopie vast, en [=, &x] legt x via referentie vast met kopiëren als standaard. [&, &x] is ongeldig. Een zichtbare globale variabele zoals ::offset hoeft niet te worden vastgelegd. [&] bestaat sinds C++11; hier gelden de regels van C++23.
Als beide geneste lambda’s total via referentie vastleggen, verwijzen ze naar hetzelfde object. Zou de buitenste lambda total als kopie vastleggen, dan zou de referentie van de binnenste lambda verwijzen naar de kopie in de buitenste closure. Als alleen de capture verandert, is total += amount echter ongeldig: de buitenste lambda is niet als mutable gedeclareerd, dus wordt de kopie als const behandeld. Je hebt mutable niet nodig om een niet-const-object te wijzigen dat via referentie is vastgelegd, en mutable kan de const-kwalificatie van het object niet wegnemen. Capture via referentie en het kopiëren van zo’n closure verlengen de levensduur van het object niet. Controleer voordat je een lambda teruggeeft of opslaat dat het object nog leeft wanneer de lambda het gebruikt; toegang via een bungelende referentie leidt tot ongedefinieerd gedrag. Als je een referentievariabele via referentie vastlegt, telt de levensduur van het object waarnaar die verwijst.
In R& result declareert & een lvalue-referentie, geen capture. result = f() schrijft naar het object van de aanroeper en bindt de referentie niet opnieuw. Met een parameter const int& amount kun je het argument niet via die referentie wijzigen.
Voorbeelden
#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';
}Resultaat
4 6
`add(step)` verandert `total` van `1` in `4`. De buitenste lambda geeft `4 + ::offset` terug en `record` schrijft `6` via `result`. Beide lambda’s worden uitgevoerd terwijl de gebruikte objecten nog leven. De verwachte uitvoerregel is `4 6`.
Gerelateerde lessen
- C++ · Les 15 · Gevorderd · Versie: 3
- C++ · Les 24 · Gevorderd · Versie: 3