One of the best explanations of lambda expression is given by the author of C ++ Bjarne Stroustrup in his book ***The C++ Programming Language*** Chapter 11 (ISBN-13: 978-0321563842):
What is a lambda expression?
A lambda expression, sometimes also known as lambda
function or (strictly speaking incorrectly, but colloquially) as a
lambda, is a simplified notation to define and use a anonymous function object. Instead of defining a named class with an operator (), then make an object of that class and finally
invoking it, we can use a shorthand.
When would I use one?
This is particularly useful when we want to pass an operation as a
argument to an algorithm. In the context of graphical user interfaces
(and elsewhere), such operations are often referred to as callbacks.
What class of problem do they solve that wasn't possible prior to their introduction?
Here I suppose that every action performed with the lambda expression can be resolved without them, but with much more code and much greater complexity. Lambda expression: this is the way to optimize your code and a way to make it more attractive. So sad for Stroustup:
effective ways to optimize
Some examples
through the lambda expression
void print_modulo(const vector& v, ostream& os, int m) // output v(i) to os if v(i)%m==0
{
for_each(begin(v),end(v),
(&os,m)(int x) {
if (x%m==0) os << x << 'n';
});
}
or through the function
class Modulo_print {
ostream& os; // members to hold the capture list int m;
public:
Modulo_print(ostream& s, int mm) :os(s), m(mm) {}
void operator()(int x) const
{
if (x%m==0) os << x << 'n';
}
};
or even
void print_modulo(const vector& v, ostream& os, int m)
// output v(i) to os if v(i)%m==0
{
class Modulo_print {
ostream& os; // members to hold the capture list
int m;
public:
Modulo_print (ostream& s, int mm) :os(s), m(mm) {}
void operator()(int x) const
{
if (x%m==0) os << x << 'n';
}
};
for_each(begin(v),end(v),Modulo_print{os,m});
}
if you need you can name lambda expression as below:
void print_modulo(const vector& v, ostream& os, int m)
// output v(i) to os if v(i)%m==0
{
auto Modulo_print = (&os,m) (int x) { if (x%m==0) os << x << 'n'; };
for_each(begin(v),end(v),Modulo_print);
}
Or assume another simple sample
void TestFunctions::simpleLambda() {
bool sensitive = true;
std::vector v = std::vector({1,33,3,4,5,6,7});
sort(v.begin(),v.end(),
(sensitive)(int x, int y) {
printf("n%in", x < y);
return sensitive ? x < y : abs(x) < abs(y);
});
printf("sorted");
for_each(v.begin(), v.end(),
()(int x) {
printf("x - %i;", x);
}
);
}
will generate the next
0 0
one
0 0
one
0 0
one
0 0
one
0 0
one
0 rated x - 1; x - 3; x - 4; x - 5; x - 6; x - 7; x - 33;
() - this is the capture list or lambda introducer: Yes lambdas Do not require access to your local environment, we can use it.
Book Quote:
The first character of a lambda expression is always (. A lambda
The presenter can take several forms:
• (): An empty capture list. Is
implies that local names of the surrounding context cannot be used
in the lambda body For such lambda expressions, the data is obtained from
arguments or non-local variables.
• (&): implicitly captured by
reference. All local names can be used. All local variables are
Accessed by reference.
• (=): implicitly capture by value. All local
Names can be used. All names refer to copies of local variables.
taken at the call point of the lambda expression.
• (capture list): explicit capture; The capture list is the list of local variable names that will be captured (that is, stored in the object) by reference or by value. Variables with names preceded by & are captured by
reference. Other variables are captured by value. A capture list can
It also contains this and names followed by ... as elements.
• (&, capture list): implicitly captures by reference all local variables with names not mentioned in the list. The capture list may contain this. The names listed cannot be preceded by &. Variables named in the
The capture list is captured by value.
• (=, capture list): implicitly captures by value all local variables with names not mentioned in the list. The capture list cannot contain this. The names listed must be preceded by &. Variables named in the capture list are captured by reference.
Note that a local name preceded by & is always captured by
reference and a local name not preceded by and is always captured by
value. Only the capture by reference allows the modification of variables in
The calling environment
Additional
Lambda expression Format
Additional References:
