Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Cattura per riferimento in una lambda: `[&]`

`[&]` imposta la cattura per riferimento come predefinita: la lambda usa gli oggetti locali originali, non le loro copie, senza prolungarne la durata di vita.

Versione: ISO C++23; implementation support may vary

Sintassi

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

[&] imposta la cattura per riferimento come modalità predefinita di una lambda. Vengono catturate implicitamente le variabili idonee con durata di memorizzazione automatica negli ambiti esterni il cui uso richiede una cattura, non tutte le variabili visibili. [&x] cattura esplicitamente solo x per riferimento; [&, x] cattura x per copia e [=, &x] cattura x per riferimento con cattura per copia predefinita. [&, &x] non è valido. Una variabile globale visibile come ::offset non richiede cattura. [&] esiste da C++11; qui valgono le regole di C++23.

Se entrambe le lambda annidate catturano total per riferimento, si riferiscono allo stesso oggetto. Se la lambda esterna catturasse total per copia, il riferimento della lambda interna designerebbe la copia nella chiusura esterna. Cambiare soltanto la cattura renderebbe però total += amount non valido: la lambda esterna non è dichiarata mutable, quindi la copia viene trattata come const. mutable non serve per modificare un oggetto non const catturato per riferimento e non può rimuovere la qualifica const dell’oggetto. Né la cattura per riferimento né la copia di una chiusura che cattura l’oggetto per riferimento ne prolunga la vita. Prima di restituire o memorizzare una lambda, verifica che l’oggetto sia ancora in vita quando verrà usato: accedervi tramite un riferimento pendente causa comportamento indefinito. Se catturi per riferimento una variabile di tipo riferimento, conta la vita dell’oggetto a cui è legata.

In R& result, & dichiara un riferimento lvalue, non una cattura. result = f() assegna un valore all’oggetto del chiamante, senza cambiare l’oggetto a cui il riferimento è legato. Un parametro const int& amount non permette di modificare l’argomento tramite quel riferimento.

Esempi

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

Risultato

4 6

`add(step)` cambia `total` da `1` a `4`. La lambda esterna restituisce `4 + ::offset` e `record` scrive `6` tramite `result`. Entrambe le lambda vengono eseguite mentre gli oggetti che usano sono ancora in vita. La riga di output attesa è `4 6`.

Lezioni correlate

  • C++ · Lezione 15 · Avanzato · Versione: 3
  • C++ · Lezione 24 · Avanzato · Versione: 3

Fonti