CKTIS / C++
Captura por cópia em lambdas de C++
Captura um limiar por valor para que o predicado continue a usá-lo mesmo que a variável original mude.
Versão: ISO C++23; implementation support may vary
Sintaxe
[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)Ao avaliar uma expressão lambda, é criado um objeto de fecho. [cost] inicializa diretamente um membro desse objeto com o valor atual da variável local cost, no momento da criação e não na chamada. [=] define a captura por cópia para as variáveis locais capturadas implicitamente, mas não copia todas as variáveis no âmbito. [limit = cost] é uma captura com inicializador (desde C++14) que guarda o valor com o novo nome limit.
Numa lambda não estática sem um parâmetro de objeto explícito, operator() é const por omissão. mutable permite ao corpo alterar uma cópia guardada que não seja const, não o original. Não retira const de um membro e não pode ser combinado com um parâmetro de objeto explícito (C++23). Já numa lambda declarada static (desde C++23), o operador de chamada é estático e não tem o qualificador const.
[&cost] refere-se ao original e acompanha as alterações posteriores. Não prolonga o tempo de vida do original; aceder-lhe depois de esse tempo terminar pode causar comportamento indefinido. Um int guardado no fecho pode sobreviver ao original, mas copiar um ponteiro simples não copia o objeto apontado nem o mantém vivo.
Num vetor const, std::vector::begin e std::vector::end devolvem um const_iterator. Delimitam um intervalo semiaberto, do início até à posição a seguir ao último elemento, que não deve ser desreferenciada. std::count_if conta os elementos para os quais o predicado devolve true. Aqui, price <= cost limita-se a comparar com o limiar guardado, sem alterar os elementos nem qualquer estado.
Usa #include diretamente para <algorithm>, <iostream> e <vector> em vez de depender de inclusões transitivas. O operador de inserção << escreve a contagem e '\n' em std::cout. A mudança de linha, por si só, não pede o esvaziamento do buffer do fluxo; std::endl acrescenta uma mudança de linha e chama flush().
Exemplos
#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';
}
Resultado
3
Após `cost = 4`, o predicado ainda usa o valor `10` guardado: `4`, `7` e `10` satisfazem a condição. O programa escreve `3`; com `[&cost]` escreveria `1`.
Lições relacionadas
- C++ · Lição 40 · Avançado · Versão: 3
Fontes
- 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]