El problema
C ++ incluye funciones genéricas útiles como std::for_eachy std::transform, que pueden ser muy útiles. Desafortunadamente, también pueden ser bastante engorrosos de usar, especialmente si el functor que desea aplicar es único para la función particular.
#include <algorithm>
#include <vector>
namespace {
struct f {
void operator()(int) {
// do something
}
};
}
void func(std::vector<int>& v) {
f f;
std::for_each(v.begin(), v.end(), f);
}
Si solo usa funa vez y en ese lugar específico, parece excesivo escribir toda una clase solo para hacer algo trivial y único.
En C ++ 03 puede que tenga la tentación de escribir algo como lo siguiente, para mantener el functor local:
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
sin embargo, esto no está permitido, fno se puede pasar a una función de plantilla en C ++ 03.
La nueva solución
C ++ 11 presenta lambdas que le permiten escribir un functor anónimo en línea para reemplazar el struct f. Para pequeños ejemplos simples, esto puede ser más limpio de leer (mantiene todo en un solo lugar) y potencialmente más simple de mantener, por ejemplo en la forma más simple:
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Las funciones de Lambda son simplemente azúcar sintáctica para functores anónimos.
Tipos de retorno
En casos simples, el tipo de retorno de la lambda se deduce por usted, por ejemplo:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
sin embargo, cuando comience a escribir lambdas más complejas, encontrará rápidamente casos en los que el compilador no puede deducir el tipo de retorno, por ejemplo:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
Para resolver esto, puede especificar explícitamente un tipo de retorno para una función lambda, utilizando -> T:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) -> double {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
Variables de "captura"
Hasta ahora no hemos usado nada más que lo que se pasó al lambda dentro de él, pero también podemos usar otras variables, dentro del lambda. Si desea acceder a otras variables, puede usar la cláusula de captura (la []de la expresión), que hasta ahora no se ha utilizado en estos ejemplos, por ejemplo:
void func5(std::vector<double>& v, const double& epsilon) {
std::transform(v.begin(), v.end(), v.begin(),
[epsilon](double d) -> double {
if (d < epsilon) {
return 0;
} else {
return d;
}
});
}
Puede capturar tanto por referencia como por valor, que puede especificar usando &y =respectivamente:
[&epsilon] captura por referencia[&] captura todas las variables utilizadas en el lambda por referencia[=] captura todas las variables utilizadas en lambda por valor[&, epsilon] captura variables como con [&], pero epsilon por valor[=, &epsilon] captura variables como con [=], pero epsilon por referencia
El generado operator()es constpor defecto, con la implicación de que las capturas serán constcuando accedas a ellas por defecto. Esto tiene el efecto de que cada llamada con la misma entrada produciría el mismo resultado, sin embargo, puede marcar el lambdamutable para solicitar que lo operator()que se produce no sea const.
