Las funciones lambda en C++ permiten definir funciones anónimas de manera concisa y flexible. Introducidas en C++11 y mejoradas en versiones posteriores, las lambdas son muy útiles para expresiones cortas y para capturar variables del contexto circundante.
La sintaxis general de una lambda es:
[captura](parámetros) -> tipo_de_retorno { cuerpo };
Veamos un ejemplo:
#include <iostream>
int main() {
auto suma = [](int a, int b) -> int {
return a + b;
};
std::cout << "La suma es: " << suma(3, 4) << std::endl;
return 0;
}
Las lambdas pueden capturar variables del contexto donde se definen. Su puede captura por Valor
#include <iostream>
int main() {
int x = 10;
auto lambda = [x]() { std::cout << "x = " << x << std::endl; };
lambda();
return 0;
}
Como x se captura por valor, cualquier cambio dentro de la lambda no afectará la variable original.
Y captura por Referencia:
#include <iostream>
int main() {
int x = 10;
auto lambda = [&x]() { x += 5; };
lambda();
std::cout << "x después de la lambda: " << x << std::endl;
return 0;
}
Dado que x se captura por referencia, su modificación dentro de la lambda afecta la variable original.
Se puede capturar todo el entorno automáticamente:
- [=] captura todas las variables por valor.
- [&] captura todas las variables por referencia.
#include <iostream>
int main() {
int a = 5, b = 10;
auto lambda = [=]() { std::cout << "a + b = " << (a + b) << std::endl; };
lambda();
return 0;
}
Las lambdas pueden almacenarse en std::function para mayor flexibilidad:
#include <iostream>
#include <functional>
int main() {
std::function<int(int, int)> multiplicar = [](int x, int y) { return x * y; };
std::cout << "Multiplicación: " << multiplicar(3, 4) << std::endl;
return 0;
}
Las lambdas son útiles para definir comparaciones personalizadas:
Por ejemplo:
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> nums = {3, 1, 4, 1, 5, 9};
std::sort(nums.begin(), nums.end(), [](int a, int b) {
return a > b;
});
for (int n : nums) std::cout << n << " ";
return 0;
}
Las funciones lambda en C++ permiten definir funciones anónimas de manera flexible y eficiente. Son especialmente útiles en programación funcional, expresiones cortas y manejo de algoritmos en la STL.
