CKTIS / C++
Vastleggen door kopiëren in C++-lambda’s
Leg een grenswaarde vast als kopie, zodat het predicaat die blijft gebruiken wanneer de oorspronkelijke variabele verandert.
Versie: ISO C++23; implementation support may vary
Syntax
[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)Bij het evalueren van een lambda-expressie ontstaat een closure-object. [cost] initialiseert een datalid van dat object rechtstreeks met de huidige waarde van de lokale variabele cost, bij het aanmaken en niet bij het aanroepen. Met [=] worden impliciet vastgelegde lokale variabelen standaard gekopieerd, niet alle variabelen binnen het bereik. [limit = cost] is een capture met initializer (sinds C++14) die de waarde opslaat onder de nieuwe naam limit.
Bij een niet-statische lambda zonder expliciete objectparameter is operator() standaard const. Met mutable mag de body een opgeslagen kopie wijzigen die niet const is, maar niet het origineel. mutable haalt const niet van een datalid af en kan niet worden gecombineerd met een expliciete objectparameter (C++23). Bij een lambda die als static is gedeclareerd (sinds C++23) is de aanroepoperator daarentegen statisch en niet const-gekwalificeerd.
[&cost] verwijst naar het origineel en ziet latere wijzigingen. Het verlengt de levensduur van het origineel niet; toegang na afloop daarvan kan ongedefinieerd gedrag veroorzaken. Een opgeslagen int kan als onderdeel van de closure langer leven dan het origineel, maar het kopiëren van een ruwe pointer kopieert het aangewezen object niet en houdt het evenmin in leven.
Voor een const-vector geven std::vector::begin en std::vector::end een const_iterator terug. Ze begrenzen een halfopen bereik vanaf het begin tot de positie voorbij het laatste element, die je niet mag derefereren. std::count_if telt de elementen waarvoor het predicaat true retourneert. Hier vergelijkt price <= cost alleen met de opgeslagen grenswaarde, zonder elementen of toestand te wijzigen.
Gebruik #include rechtstreeks voor <algorithm>, <iostream> en <vector> in plaats van op transitieve includes te vertrouwen. De invoegoperator << schrijft de telling en '\n' naar std::cout. Een regeleinde alleen vraagt niet om de stroombuffer te legen; std::endl voegt een regeleinde toe en roept flush() aan.
Voorbeelden
#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';
}
Resultaat
3
Na `cost = 4` gebruikt het predicaat nog steeds de opgeslagen `10`: `4`, `7` en `10` voldoen aan de voorwaarde. Het programma toont `3`; met `[&cost]` zou het `1` tonen.
Gerelateerde lessen
- C++ · Les 40 · Gevorderd · Versie: 3
Bronnen
- N4950 — Working Draft, Standard for Programming Language C++
- Captures [expr.prim.lambda.capture]
- Closure types [expr.prim.lambda.closure]
- Class template vector — Overview [vector.overview]
- Container requirements [container.reqmts]
- Count [alg.count]
- Source file inclusion [cpp.include]
- basic_ostream::operator<< [ostream.inserters]
- Character inserter function templates [ostream.inserters.character]
- Standard basic_ostream manipulators [ostream.manip]