Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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