En C++ las funciones anónimas (lambdas) se definen con la siguiente sintaxis general:
[capturas](parámetros) -> tipo_retorno {
// cuerpo de la función
}
La parte más llamativa son los corchetes [] al inicio.
Ahí se especifica cómo la lambda accede a las variables externas a su alcance (scope).
¿Por qué C++ necesita los []? En muchos lenguajes (como JavaScript o Python) las funciones anónimas pueden usar directamente variables externas sin decir nada especial.
En cambio, C++ es un lenguaje con:
- tipado fuerte,
- control de memoria explícito,
- y reglas claras de tiempo de vida de las variables.
Por eso, el estándar obliga a indicar en los [] qué variables del entorno queremos capturar y cómo (por valor o por referencia).
Esto evita accesos accidentales y hace explícito el costo en memoria/copias.
Modos de captura en C++ :
1. Sin captura
[]() { cout << "Hola lambda!" << endl; }();
La lambda no accede a nada externo. Sirve como función pura.
2. Captura por valor
int x = 10;
auto f = [x]() { cout << x << endl; };
f(); // imprime 10
Se copia la variable x dentro de la lambda. Y si después cambias x, la lambda no lo ve.
3. Captura por referencia
int x = 10;
auto f = [&x]() { x++; };
f();
cout << x << endl; // imprime 11
Se captura la referencia, por lo que la lambda puede modificar la variable externa.
4. Captura de todo por valor
int a = 1, b = 2;
auto f = [=]() { cout << a + b << endl; };
f(); // imprime 3
5. Captura de todo por referencia
int a = 1, b = 2;
auto f = [&]() { a++; b++; };
f();
cout << a << ", " << b << endl; // imprime 2, 3
6. Mixtas
int a = 1, b = 2;
auto f = [=, &b]() { cout << a + b << endl; b++; };
f(); // imprime 3
cout << b << endl; // 3
Aquí capturamos todo por valor, excepto b que es por referencia.
7. Captura de `this`
En clases, podemos capturar this para acceder a miembros:
class Persona {
int edad = 20;
public:
void mostrar() {
auto f = [this]() { cout << edad << endl; };
f();
}
};
Desde C++17 también existe [=, this] (por valor y this por referencia implícita).
Los [] de una lambda en C++ son la forma explícita de indicar qué variables externas queremos usar y cómo.
Esto es necesario porque:
- C++ cuida la propiedad de los datos.
- No siempre es obvio si queremos copiar o referenciar algo.
- Evita errores de memoria y da más control al programador.
