Problem
C ++ zawiera przydatne funkcje ogólne, takie jak std::for_eachi std::transform, które mogą być bardzo przydatne. Niestety mogą być również uciążliwe w użyciu, szczególnie jeśli funktor , który chcesz zastosować, jest unikalny dla konkretnej funkcji.
#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);
}
Jeśli użyjesz tylko fraz i w tym konkretnym miejscu, wydaje się przesadą pisać całą klasę, aby zrobić coś trywialnego i jednorazowego.
W C ++ 03 możesz mieć ochotę napisać coś takiego, aby utrzymać funktor lokalny:
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
jednak nie jest to dozwolone, fnie można go przekazać do funkcji szablonu w C ++ 03.
Nowe rozwiązanie
C ++ 11 wprowadza lambdas, które pozwalają napisać wbudowany, anonimowy funktor, który zastąpi struct f. W przypadku małych prostych przykładów może to być łatwiejsze do odczytania (utrzymuje wszystko w jednym miejscu) i potencjalnie prostsze w utrzymaniu, na przykład w najprostszej formie:
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Funkcje lambda to po prostu cukier syntaktyczny dla anonimowych funktorów.
Typy zwrotów
W prostych przypadkach obliczany jest typ zwrotu lambda, np .:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
jednak kiedy zaczniesz pisać bardziej złożone lambdy, szybko napotkasz przypadki, w których kompilator nie może wydedukować typu zwrotu, np .:
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;
}
});
}
Aby rozwiązać ten problem, możesz jawnie określić typ zwracany dla funkcji lambda, używając -> 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;
}
});
}
Zmienne „przechwytywanie”
Do tej pory nie używaliśmy niczego innego niż to, co zostało przekazane do niej w lambdzie, ale możemy również używać innych zmiennych w obrębie lambda. Jeśli chcesz uzyskać dostęp do innych zmiennych, możesz użyć klauzuli przechwytywania ( []wyrażenia), która do tej pory nie była używana w tych przykładach, np .:
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;
}
});
}
Możesz przechwytywać zarówno według odwołania, jak i wartości, które możesz określić za pomocą &i =odpowiednio:
[&epsilon] przechwytywanie przez odniesienie[&] przechwytuje wszystkie zmienne używane w lambda przez odniesienie[=] przechwytuje wszystkie zmienne używane w lambda według wartości[&, epsilon] przechwytuje zmienne takie jak z [&], ale epsilon według wartości[=, &epsilon] przechwytuje zmienne jak z [=], ale epsilon przez odniesienie
Generowane operator()jest constdomyślnie, z implikacją, że przechwytywanie nastąpi constpo domyślnym dostępie do nich. Powoduje to, że każde wywołanie z tym samym wejściem daje ten sam wynik, jednak można oznaczyć lambda jakomutable żądanie, operator()aby nie zostało wygenerowane const.
