Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Cattura per copia nelle lambda C++

Cattura una soglia per valore, così il predicato continua a usarla anche se la variabile originale cambia.

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

Sintassi

[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)

La valutazione di un’espressione lambda crea un oggetto di chiusura. [cost] inizializza direttamente un membro dell’oggetto con il valore corrente della variabile locale cost, alla creazione e non alla chiamata. [=] imposta la cattura per copia come modalità predefinita per le variabili locali catturate implicitamente, senza copiare tutte le variabili visibili. [limit = cost] è una cattura con inizializzatore (da C++14) che memorizza il valore con il nuovo nome limit.

In una lambda non statica senza un parametro oggetto esplicito, operator() è const per impostazione predefinita. mutable permette al corpo di modificare una copia memorizzata non const, non l’originale. Non rimuove const da un membro e non può essere combinato con un parametro oggetto esplicito (C++23). Una lambda dichiarata static (da C++23) ha invece un operatore di chiamata statico, privo del qualificatore const.

[&cost] fa riferimento all’originale e ne vede le modifiche successive. Non ne prolunga la durata di vita: accedervi dopo che è terminata può causare comportamento indefinito. Un int memorizzato nella chiusura può sopravvivere all’originale, ma copiare un puntatore grezzo non copia l’oggetto puntato né lo mantiene in vita.

Per un vettore const, std::vector::begin e std::vector::end restituiscono un const_iterator. Delimitano un intervallo semiaperto dall’inizio alla posizione oltre l’ultimo elemento, che non va dereferenziata. std::count_if conta gli elementi per cui il predicato restituisce true. Qui price <= cost confronta soltanto con la soglia memorizzata, senza modificare gli elementi né alcuno stato.

Usa #include direttamente per <algorithm>, <iostream> e <vector> invece di affidarti a inclusioni transitive. L’operatore di inserimento << scrive il conteggio e '\n' in std::cout. Il solo carattere di fine riga non richiede lo svuotamento del buffer del flusso; std::endl aggiunge un fine riga e chiama flush().

Esempi

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

Risultato

3

Dopo `cost = 4`, il predicato usa ancora il valore memorizzato `10`: `4`, `7` e `10` soddisfano la condizione. Il programma stampa `3`; con `[&cost]` stamperebbe `1`.

Lezioni correlate

  • C++ · Lezione 40 · Avanzato · Versione: 3

Fonti