{"id":5661,"date":"2019-04-11T20:38:56","date_gmt":"2019-04-11T20:38:56","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-insights-lambdas\/"},"modified":"2023-06-26T10:12:20","modified_gmt":"2023-06-26T10:12:20","slug":"c-insights-lambdas","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-insights-lambdas\/","title":{"rendered":"C++ Insights – Lambdas"},"content":{"rendered":"

Honestly, many programmers in my classes have issues with the syntactic sugar of lambdas. Desugaring lambdas with C++ Insights helps quite often.<\/p>\n

<\/p>\n

 \"05<\/p>\n

Lambdas<\/h2>\n

Lambdas in C++ seems to be the most interesting new language feature. My opinion is based on all the issue reports and emails I got for C++ Insights so far.<\/p>\n

They allow us to capture variables in different ways. Due to their lightweight syntax, it\u2019s easy to create new functions like objects. In case, you never heard of it, lambdas are essentially classes with a call operator. The lambda body we provide is then the body of the call operator. For starters that should be it. Actually, lambdas are one of the reasons I created C++ Insights. It can show this transformation which, at least for me, makes it easier to explain. But see for yourself<\/a>:<\/p>\n

int<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  char<\/span> c{1<\/span>};\r\n  \r\n  auto<\/span> l = [=] () { return<\/span> c; };\r\n\r\n  return<\/span> l();\r\n}<\/code><\/pre>\n
Capture Options<\/h3>\n
Things get more interesting if we start talking about the capture options. A variable that is captured by reference becomes a reference member of the lambdas class. Have a close look at the signature of the call operator. It says const. However, I can still modify x. It\u2019s just a reference and not a const reference as you can see in C++ Insights<\/a>:<\/p>\n
int<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  char<\/span> x{1<\/span>};\r\n  \r\n  auto<\/span> l = [&] () { \r\n    x = 1<\/span>;\r\n  };\r\n}\r\n<\/code><\/pre>\n
int<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  char<\/span> c{1<\/span>};\r\n  \r\n  auto<\/span> l = [=] () { return<\/span> c; };\r\n  \r\n  auto<\/span> l2 = [=] () mutable<\/span> { \r\n    c = 1<\/span>;\r\n    \r\n    return<\/span> c;\r\n  };\r\n}\r\n<\/code><\/pre>\n
int<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  char<\/span> c;\r\n  int<\/span> x;\r\n  char<\/span> b;\r\n  \r\n  auto<\/span> l = [=] () mutable<\/span> { \r\n    c = 1<\/span>,\r\n    x = 2<\/span>;\r\n    b = 3<\/span>;\r\n  };\r\n  \r\n  static_assert<\/span>(sizeof<\/span>(l) == sizeof<\/span>(int<\/span>)*3<\/span>);\r\n  \r\n  auto<\/span> l2 = [=] () mutable<\/span> { \r\n    x = 2<\/span>;\r\n    c = 1<\/span>,\r\n    b = 3<\/span>;\r\n  };\r\n  \r\n  static_assert<\/span>(sizeof<\/span>(l2) == sizeof<\/span>(int<\/span>)*2<\/span>);\r\n}\r\n<\/code><\/pre>\n
However, please note that the order of the members in the class is unspecified.<\/p>\n
Another thing to watch out for is lambdas containing captures by reference. The variables these references point to, need to be valid when the lambda is invoked otherwise you end up with a dangling reference. Here is such an example:<\/p>\n
auto<\/span> Lambda<\/span>()<\/span>\r\n<\/span>{\r\n  int<\/span> x{};\r\n  \r\n  return<\/span> [&]{ return<\/span> x; };\r\n}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  Lambda()();\r\n}\r\n<\/code><\/pre>\n
__lambda_5_10 Lambda<\/span>()<\/span>\r\n<\/span>{\r\n  int<\/span> x = {};\r\n    \r\n  class<\/span> __lambda_5_10\r\n  {\r\n    int<\/span> & x;\r\n    public<\/span>: inline<\/span> \/*constexpr *\/<\/span> int<\/span> operator<\/span>()<\/span>()<\/span> const<\/span>\r\n    <\/span>{\r\n      return<\/span> x;\r\n    }\r\n    \r\n    public<\/span>: __lambda_5_10(int<\/span> & _x)\r\n    : x{_x}\r\n    {}\r\n    \r\n  } __lambda_5_10{x};\r\n  \r\n  return<\/span> __lambda_5_10;\r\n}\r\n\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  Lambda().operator<\/span>()();\r\n}\r\n<\/code><\/pre>\n
You already knew that? Excellent! You are either careful or use copy captures because then you are safe? Well, let\u2019s see.<\/p>\n
auto<\/span> Lambda<\/span>()<\/span>\r\n<\/span>{\r\n  int<\/span>  y{};\r\n  int<\/span>* x{&y};\r\n\r\n  return<\/span> [=]{ return<\/span> x; };\r\n}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  auto<\/span> x = Lambda()();\r\n}\r\n<\/code><\/pre>\n
Here we capture only by copy, but we still return something on the stack. The pointer we copy-capture is still a pointer pointing to something on the stack which is no longer valid after we left Lambda<\/code>.<\/p>\n<\/p>\n
Deeper Insights<\/h3>\n
At this point we covered templates, variadic templates, fold expressions, constexpr if and lambdas. We have seen how C++ Insights can show us the internals or the details. How about using them all together? Like this:<\/p>\n
#include<\/span> <string><\/span><\/span>\r\n#include<\/span> <type_traits><\/span><\/span>\r\n\r\ntemplate<\/span> <typename<\/span>... Ts>\r\nstd<\/span>::string<\/span> stringify<\/span>(Ts&&... args)<\/span>\r\n<\/span>{\r\n  auto<\/span> convert = [](auto<\/span>&& arg) {\r\n    using<\/span> TT = std<\/span>::remove_reference_t<\/span><decltype<\/span>(arg)>;\r\n    if<\/span> constexpr<\/span>(std<\/span>::is_same_v<TT, std<\/span>::string<\/span>>)<\/span> <\/span>{\r\n      return<\/span> arg;\r\n    } else<\/span> if<\/span> constexpr<\/span>(std<\/span>::is_array_v< TT >)<\/span> <\/span>{\r\n      return<\/span> std<\/span>::string<\/span>{arg};\r\n    } else<\/span> {\r\n      return<\/span> std<\/span>::to_string(arg);\r\n    }\r\n  };\r\n  \r\n  std<\/span>::string<\/span> ret{};\r\n  auto<\/span> concat = [](std<\/span>::string<\/span>& dst, auto<\/span>&& arg) {\r\n    dst += arg;\r\n  };\r\n  \r\n  (..., concat(ret, convert(args)));\r\n   \r\n  return<\/span> ret;\r\n}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  std<\/span>::string<\/span> hello{\"hello \"<\/span>};\r\n  auto<\/span> s = stringify(\"A \"<\/span>, hello, 2<\/span>, \" \"<\/span>, \"C++ Insights\"<\/span>);\r\n\r\n  printf<\/span>(\"%s\\n\"<\/span>, s.c_str());\r\n}\r\n<\/code><\/pre>\n
I\u2019d like to mention one caveat at this point. The two lambdas convert<\/code> and concat<\/code> are generic lambdas. Internally they have a call operator which is a template. This is how we can have the auto parameter. Sadly, C++ Insights does not show this part yet. It\u2019s on the list and maybe fixed soon. I think it\u2019s worth knowing this.<\/p>\n
Amazing what we can do, right? I really like the way we can write code using the latest standard. I\u2019m also happy to offer you my training services to let you benefit from my knowledge.<\/p>\n
I\u2019d like to thank Rainer for the opportunity to share information about C++ Insights on his popular blog!<\/p>\n
Have fun with C++ Insights. You can support the project by becoming a Patreon<\/a> or of course with code contributions<\/a>.<\/p>\n
This is the last post of the series here. I hope you enjoyed reading it and took something from it. Now, its up to you to explore more about C++ Insights and the language itself.<\/p>\n
I am Fertig.<\/strong><\/p>\n
Andreas<\/strong><\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Honestly, many programmers in my classes have issues with the syntactic sugar of lambdas. Desugaring lambdas with C++ Insights helps quite often.<\/p>\n","protected":false},"author":21,"featured_media":5660,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[374],"tags":[459],"class_list":["post-5661","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cppinsight","tag-lambdas"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5661","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5661"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5661\/revisions"}],"predecessor-version":[{"id":6792,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5661\/revisions\/6792"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5660"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5661"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5661"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5661"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Here, we have a variadic template that contains two lambdas. The first one (convert) does the conversion from anything into a string. This is similar to what we had in the previous post. The second one concatenates all arguments. Then in the line, (..., concat(ret, convert(args)));<\/code> all arguments get expanded by the fold expression and with the use of the comma operator. Neat and reasonably small, at least in my opinion. How does this code look internally? Have a look at C++ Insights<\/a>. With all the templates, the code gets a little too big to show it here.<\/p>\n
How about this nice copy capture example<\/a>:<\/p>\n
I think it becomes pretty clear with a look at C++ Insights<\/a>:<\/p>\n
Knowing that a class is behind a lambda enables us to think a bit more about things, like for example the size of a lambda. Copy captures increase the size by their size plus eventually padding. To save some bytes the ordering of the captures matters as you can see here<\/a>:<\/p>\n
Things change if we capture by copy. Then, the captured variable is a copy. Now the const matters, we can\u2019t modify x without adding mutable to the lambda definition<\/a>:<\/p>\n