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

CKTIS / C++

Captura por referência numa expressão lambda: `[&]`

`[&]` estabelece a captura por referência por omissão: a expressão lambda utiliza os objetos locais originais, em vez de cópias, sem prolongar o seu tempo de vida.

Versão: ISO C++23; implementation support may vary

Sintaxe

[&](parameters) { body }
[&x](parameters) { body }
[&, x](parameters) { body }
[=, &x](parameters) { body }

[&] define a captura por referência como modo por omissão de uma expressão lambda. A captura implícita abrange as variáveis elegíveis com duração de armazenamento automática dos âmbitos envolventes cuja utilização exige captura, não todas as variáveis visíveis. [&x] captura explicitamente apenas x por referência; [&, x] captura x por cópia e [=, &x] captura x por referência com captura por cópia por omissão. [&, &x] é inválido. Uma variável global visível como ::offset não precisa de ser capturada. [&] existe desde C++11; aqui aplicam-se as regras de C++23.

Se ambas as lambdas aninhadas capturarem total por referência, referem-se ao mesmo objeto. Se a lambda exterior capturasse total por cópia, a referência da lambda interior apontaria para a cópia no objeto de fecho exterior. Alterar apenas a captura tornaria, porém, total += amount inválido: a lambda exterior não está declarada como mutable, pelo que a cópia é tratada como const. Não é necessário mutable para alterar um objeto não const capturado por referência, e mutable não pode retirar a qualificação const do objeto. Nem a captura por referência nem a cópia de um objeto de fecho que captura o objeto por referência prolonga o seu tempo de vida. Antes de devolver ou guardar uma lambda, garante que o objeto ainda existe quando for utilizado; aceder-lhe por uma referência pendente tem comportamento indefinido. Se capturares por referência uma variável de tipo referência, conta o tempo de vida do objeto a que está ligada.

Em R& result, & declara uma referência lvalue, não uma captura. result = f() atribui um valor ao objeto do chamador; não altera a ligação da referência. Um parâmetro const int& amount não permite modificar o argumento através dessa referência.

Exemplos

#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';
}

Resultado

4 6

`add(step)` altera `total` de `1` para `4`. A lambda exterior devolve `4 + ::offset` e `record` escreve `6` através de `result`. Ambas as lambdas são executadas enquanto os objetos que usam ainda existem. A linha de saída esperada é `4 6`.

Lições relacionadas

  • C++ · Lição 15 · Avançado · Versão: 3
  • C++ · Lição 24 · Avançado · Versão: 3

Fontes