![\"Lambda\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/09\/Lambda.jpg\")
<\/p>\nI can not think about modern C++ without lambda expressions. So my wrong assumption was that there are many rules for lambda expressions. Wrong! There are fewer than ten rules. But as ever I learned something new.<\/p>\n
<\/p>\n
Here are the first four rules for lambda expressions (short lambdas).<\/p>\n
<\/p>\n
const<\/code> variables<\/a><\/li>\n<\/ul>\nI said I wanted to write about lambda functions. Maybe you are surprised that the headline is called function objects and lambdas. If you know that lambdas are just function objects automatically created by the compiler, then this will not surprise you. If you don’t know, read the following section because knowing this magic helps a lot in getting a deeper understanding of lambda expressions. <\/p>\n
I will make it short because I plan to write about lambda expressions.<\/p>\n
Lambda functions under the hood<\/h3>\n
First, a function object is an instance of a class, for which the call operator ( operator()<\/span> ) is overloaded. This means that a function object is an object that behaves like a function. The main difference between a function and a function object is: a function object is an object and can, therefore, have stated.<\/p>\nHere is a simple example.<\/p>\n
<\/p>\n
\nint<\/span> addFunc<\/span>(int<\/span> a, int<\/span> b){ return<\/span> a +<\/span> b; }\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n struct<\/span> AddObj{\r\n int<\/span> operator<\/span>()(int<\/span> a, int<\/span> b) const<\/span> { return<\/span> a +<\/span> b; }\r\n };\r\n \r\n AddObj addObj;\r\n addObj(3<\/span>, 4<\/span>) ==<\/span> addFunc(3<\/span>, 4<\/span>);
\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Instances of the struct AddObj<\/span> and the function addFunc<\/span> are both callables. I defined the struct AddObj<\/span> just in place. The C++ compiler implicitly does that if I use a lambda expression.<\/p>\nHave a look.<\/p>\n
<\/p>\n
\nint<\/span> addFunc<\/span>(int<\/span> a, int<\/span> b){ return<\/span> a +<\/span> b; }\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n auto<\/span> addObj =<\/span> [](int<\/span> a, int<\/span> b){ return<\/span> a +<\/span> b; };\r\n \r\n addObj(3<\/span>, 4<\/span>) ==<\/span> addFunc(3<\/span>, 4<\/span>);\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
That’s all!<\/strong> If the lambda expression captures its environment and therefore has state, the corresponding struct AddOb<\/span>j gets a constructor for initializing its members. If the lambda expression captures its argument by reference, so does the constructor. The same holds for capturing by value.<\/p>\nWith C++14, we have generic lambdas; therefore, you can define a lambda expression such as [](auto a, auto b){ return a + b; };. <\/span>What does that mean for the call operator of AddObj<\/span>? I assume you can already guess it. The call operator becomes a template. I want to emphasize it explicitly: a generic lambda is a function template<\/strong>. <\/span><\/p>\nI hope this section was not too concise. Let’s continue with the four rules.<\/p>\n<\/p>\n
F.50: Use a lambda when a function won\u2019t do (to capture local variables, or to write a local function)<\/a><\/h3>\nThe difference in the usage of functions and lambda functions boils down to two points. <\/span><\/p>\n\n- You can not overload lambdas.<\/li>\n
- A lambda function can capture local variables.<\/li>\n<\/ol>\n
Here is a contrived example of the second point.<\/p>\n
<\/p>\n
\n#include <functional><\/span>\r\n\r\nstd::<\/span>function<<\/span>int<\/span>(int<\/span>)><\/span> makeLambda(int<\/span> a){ \/\/ (1)\r\n return<\/span> [a](int<\/span> b){ return<\/span> a +<\/span> b; };\r\n}\r\n\r\nint<\/span> main(){\r\n \r\n auto<\/span> add5 =<\/span> makeLambda(5<\/span>); \/\/ (2)\r\n \r\n auto<\/span> add10 =<\/span> makeLambda(10<\/span>); \/\/ (3)\r\n \r\n add5(10<\/span>) ==<\/span> add10(5<\/span>); \/\/ (4)\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The function makeLambda<\/span> returns a lambda expression. The lambda expression takes an int<\/span> and returns an int<\/span>. This is the type of the polymorph function wrapper std::function: std::function<int(int)>. (1).<\/span><\/span> Invoking makeLambda(5)<\/span> (2) creates a lambda expression that captures a, <\/span>which is, in this case, 5. The same argumentation holds for makeLambda(10) (3); therefore add5(10)<\/span> and add10(5)<\/span> are 15 (4).
<\/span><\/span><\/p>\nThe next two rules are explicitly dealing with capturing by reference. Both are pretty similar; therefore, I will present them together.<\/p>\n
F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms, <\/a>F.53: Avoid capturing by reference in lambdas that will be used nonlocally, including returned, stored on the heap, or passed to another thread<\/a><\/h3>\nFor efficiency and correctness reasons, your lambda expression should capture its variables by reference if the lambda expression is locally used. Accordingly, if the lambda expression is not used locally, you should copy the arguments and not capture the variables by reference. If you break the last statement, you will get undefined behavior.<\/p>\n
Here is an example of undefined behavior with lambda expressions.<\/p>\n
<\/p>\n
\n\/\/ lambdaCaptureReference.cpp<\/span>\r\n\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n\r\nstd::<\/span>function<<\/span>int<\/span>(int<\/span>)><\/span> makeLambda(int<\/span> a){\r\n int<\/span> local =<\/span> 2<\/span> *<\/span> a;\r\n auto<\/span> lam =<\/span> [&<\/span>local](int<\/span> b){ return<\/span> local +<\/span> b; }; \/\/ 1<\/span>\r\n std::<\/span>cout <<<\/span> \"lam(5): \"<\/span><<<\/span> lam(5<\/span>) <<<\/span> std::<\/span>endl; \/\/ 2<\/span>\r\n return<\/span> lam;\r\n}\r\n\r\nint<\/span> main(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n int<\/span> local =<\/span> 10<\/span>;\r\n \r\n auto<\/span> addLocal =<\/span> [&<\/span>local](int<\/span> b){ return<\/span> local +<\/span> b; }; \/\/ 3<\/span>\r\n \r\n auto<\/span> add10 =<\/span> makeLambda(5<\/span>);\r\n \r\n std::<\/span>cout <<<\/span> \"addLocal(5): \"<\/span> <<<\/span> addLocal(5<\/span>) <<<\/span> std::<\/span>endl; \/\/ 4<\/span>\r\n std::<\/span>cout <<<\/span> \"add10(5): \"<\/span> <<<\/span> add10(5<\/span>) <<<\/span> std::<\/span>endl; \/\/ 5<\/span>\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The lambda addLocal (3) definition and its usage (4) is fine. The same holds for the definition of the lambda expression lam<\/span> (1) and its usage (2) inside the function. The undefined behavior is that the function makeLambda<\/span> returns a lambda expression referencing the local variable local.<\/span><\/p>\n
![\"LambdaCaptureReference\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/09\/LambdaCaptureReference.png\")
<\/p>\n