Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Captura por copia en lambdas de C++

Captura un umbral por valor para que el predicado lo siga usando aunque cambie la variable original.

Versión: ISO C++23; implementation support may vary

Sintaxis

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

Al evaluar una expresión lambda se crea un objeto de cierre. [cost] inicializa directamente un miembro de ese objeto a partir del valor actual de la variable local cost, al crear el cierre y no al invocarlo. [=] establece la captura por copia para las variables locales capturadas implícitamente, pero no copia todas las variables del ámbito. [limit = cost] es una captura con inicializador (desde C++14) que guarda el valor con el nuevo nombre limit.

En una lambda no estática sin un parámetro de objeto explícito, operator() es const de forma predeterminada. mutable permite que el cuerpo modifique una copia almacenada que no sea const, no el original. No elimina const de un miembro y no puede combinarse con un parámetro de objeto explícito (C++23). En cambio, una lambda declarada static (desde C++23) tiene un operador de llamada estático, sin el calificador const.

[&cost] se refiere al original y refleja sus cambios posteriores. No prolonga su tiempo de vida; acceder a él una vez terminado puede causar comportamiento indefinido. Un int almacenado como parte del cierre puede sobrevivir al original, pero copiar un puntero sin gestión de propiedad no copia el objeto apuntado ni prolonga su tiempo de vida.

Para un vector const, std::vector::begin y std::vector::end devuelven const_iterator. Delimitan un rango semiabierto desde el inicio hasta la posición posterior al último elemento, que no se debe desreferenciar. std::count_if cuenta los elementos para los que el predicado devuelve true. Aquí price <= cost se limita a comparar con el umbral guardado, sin modificar los elementos ni ningún estado.

Usa #include directamente para <algorithm>, <iostream> y <vector> en lugar de depender de inclusiones transitivas. El operador de inserción << envía el recuento y '\n' a std::cout. El salto de línea por sí solo no solicita el vaciado del búfer del flujo; std::endl añade un salto de línea y llama a flush().

Ejemplos

#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

Después de `cost = 4`, el predicado sigue usando el `10` almacenado: `4`, `7` y `10` cumplen la condición. El programa imprime `3`; con `[&cost]` imprimiría `1`.

Lecciones relacionadas

  • C++ · Lección 40 · Avanzado · Versión: 3

Fuentes