Le problème
C ++ inclut des fonctions génériques utiles comme std::for_eachet std::transform, qui peuvent être très utiles. Malheureusement, ils peuvent également être assez lourds à utiliser, en particulier si le foncteur que vous souhaitez appliquer est unique pour la fonction particulière.
#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 vous ne l'utilisez fqu'une seule fois et à cet endroit spécifique, il semble exagéré d'écrire une classe entière juste pour faire quelque chose de trivial et unique.
En C ++ 03, vous pourriez être tenté d'écrire quelque chose comme ceci, pour garder le foncteur local:
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
cependant, cela n'est pas autorisé et fne peut pas être transmis à une fonction de modèle en C ++ 03.
La nouvelle solution
C ++ 11 introduit lambdas vous permet d'écrire un foncteur anonyme en ligne pour remplacer le struct f. Pour les petits exemples simples, cela peut être plus propre à lire (il garde tout au même endroit) et potentiellement plus simple à maintenir, par exemple sous la forme la plus simple:
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Les fonctions lambda ne sont que du sucre syntaxique pour les foncteurs anonymes.
Types de retour
Dans les cas simples, le type de retour du lambda est déduit pour vous, par exemple:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
cependant, lorsque vous commencez à écrire des lambdas plus complexes, vous rencontrerez rapidement des cas où le type de retour ne peut pas être déduit par le compilateur, par exemple:
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;
}
});
}
Pour résoudre ce problème, vous êtes autorisé à spécifier explicitement un type de retour pour une fonction lambda, en utilisant -> 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;
}
});
}
"Capture" des variables
Jusqu'à présent, nous n'avons utilisé rien d'autre que ce qui a été transmis au lambda en son sein, mais nous pouvons également utiliser d'autres variables, au sein du lambda. Si vous souhaitez accéder à d'autres variables, vous pouvez utiliser la clause de capture (celle []de l'expression), qui n'a jusqu'à présent pas été utilisée dans ces exemples, par exemple:
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;
}
});
}
Vous pouvez capturer à la fois par référence et par valeur, que vous pouvez spécifier en utilisant &et =respectivement:
[&epsilon] capture par référence[&] capture toutes les variables utilisées dans le lambda par référence[=] capture toutes les variables utilisées dans le lambda par valeur[&, epsilon] capture des variables comme avec [&], mais epsilon par valeur[=, &epsilon] capture des variables comme avec [=], mais epsilon par référence
Le généré operator()est constpar défaut, avec l'implication que les captures seront constlorsque vous y accéderez par défaut. Cela a pour effet que chaque appel avec la même entrée produirait le même résultat, mais vous pouvez marquer le lambdamutable pour demander que ce operator()qui est produit ne le soit pas const.
