O problema
O C ++ inclui funções genéricas úteis como std::for_eache std::transform, que podem ser muito úteis. Infelizmente, eles também podem ser bastante complicados de usar, principalmente se o functor que você deseja aplicar for exclusivo para a função específica.
#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);
}
Se você usa apenas fuma vez e nesse local específico, parece exagero escrever uma classe inteira apenas para fazer algo trivial e único.
No C ++ 03, você pode tentar escrever algo como o seguinte, para manter o functor local:
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
no entanto, isso não é permitido, fnão pode ser passado para uma função de modelo no C ++ 03.
A nova solução
O C ++ 11 introduz lambdas permite que você escreva um functor anônimo in-line para substituir o struct f. Para pequenos exemplos simples, isso pode ser mais fácil de ler (mantém tudo em um só lugar) e potencialmente mais simples de manter, por exemplo, da forma mais simples:
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Funções Lambda são apenas açúcar sintático para functores anônimos.
Tipos de retorno
Em casos simples, o tipo de retorno do lambda é deduzido para você, por exemplo:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
no entanto, quando você começar a escrever lambdas mais complexas, encontrará rapidamente casos em que o tipo de retorno não pode ser deduzido pelo compilador, por exemplo:
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 isso, você pode especificar explicitamente um tipo de retorno para uma função lambda, usando -> 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;
}
});
}
Variáveis de "captura"
Até agora, não usamos nada além do que foi passado para o lambda dentro dele, mas também podemos usar outras variáveis dentro do lambda. Se você deseja acessar outras variáveis, pode usar a cláusula capture (a []da expressão), que até agora não foi utilizada nesses exemplos, por exemplo:
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;
}
});
}
Você pode capturar por referência e valor, que você pode especificar usando &e =respectivamente:
[&epsilon] captura por referência[&] captura todas as variáveis usadas no lambda por referência[=] captura todas as variáveis usadas no lambda por valor[&, epsilon] captura variáveis como com [&], mas epsilon por valor[=, &epsilon] captura variáveis como com [=], mas epsilon por referência
O gerado operator()é constpor padrão, com a implicação de captura constquando você os acessa por padrão. Isso tem o efeito de que cada chamada com a mesma entrada produziria o mesmo resultado, no entanto, você pode marcar o lambdamutable para solicitar que o operator()que é produzido não seja const.
