{"id":5958,"date":"2020-08-07T06:04:01","date_gmt":"2020-08-07T06:04:01","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/more-lambdas-features-with-c-20\/"},"modified":"2023-06-26T09:46:40","modified_gmt":"2023-06-26T09:46:40","slug":"more-lambdas-features-with-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/more-lambdas-features-with-c-20\/","title":{"rendered":"More Lambda Features with C++20"},"content":{"rendered":"

Lambdas in C++20 can be default-constructed and support copy-assignment when they have no state. Lambdas can be used in unevaluated contexts. Additionally, they detect when you implicitly copy the this<\/span> pointer. This means a significant cause of undefined behavior with lambdas is gone.<\/p>\n

<\/p>\n

 \"TimelineCpp20CoreLanguage\"<\/p>\n

I want to start with the last feature of the enumeration. The compiler detects the undefined behavior when you implicitly copy the this<\/span> pointer. Okay, what does undefined behavior mean? With undefined behavior, there are no restrictions on the behavior of the program, and you have, therefore, no guarantee of what can happen.<\/strong><\/p>\n

I like to say in my seminars: When you have undefined behavior, your program has catch-fire semantics. This means your computer can even catch fire. In former days undefined behavior was described more rigorously: with undefined behavior, you can launch a cruise missile. Anyway, when you have undefined behavior, there is only one action left: fix the undefined behavior.<\/p>\n

In the next section, I intentionally cause undefined behavior.<\/p>\n

Implicitly Copy of the this<\/span> Pointer<\/h2>\n

The following program implicitly captures the this<\/span> pointer by copy.<\/p>\n

 <\/p>\n

\n
\/\/ lambdaCaptureThis.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\nstruct<\/span> Lambda {\r\n    auto<\/span> foo() const<\/span> {\r\n        return<\/span> [=<\/span>] { std::<\/span>cout <<<\/span> s <<<\/span> std::<\/span>endl; };   \/\/ (1)<\/span> \r\n    }\r\n    std::<\/span>string s =<\/span> \"lambda\"<\/span>;\r\n     ~<\/span>Lambda() {\r\n        std::<\/span>cout <<<\/span> \"Goodbye\"<\/span> <<<\/span> std::<\/span>endl;\r\n    }\r\n};\r\n\r\nauto<\/span> makeLambda<\/span>() {                                               \r\n    Lambda lambda;                                     \/\/ (2)<\/span>                               \r\n    return<\/span> lambda.foo();\r\n}                                                      \/\/ (3)<\/span>\r\n\r\n\r\nint<\/span> main<\/span>() {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    auto<\/span> lam =<\/span> makeLambda();                                \r\n    lam();                                             \/\/ (4)<\/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 compilation of the program works as expected, but this does not hold for the execution of the program.<\/p>\n
\"LambdaCaptureThis\"<\/p>\n
Do you spot the issue in the <\/span>program lambdaCaptureThis.cpp<\/span>? The member function foo (1) returns the lambda [=] { std::cout << s << std::endl; }<\/span> having an implicit copy of the this<\/span> pointer. This implicit copy is no issue in (2) but becomes an issue at the end of the scope. The end of the scope means the end of the lifetime of the local lambda<\/span> (3). Consequently, the call lam() (4) triggers undefined behavior.<\/p>\n
A C++20 compiler must, in this case, write a warning. Here is the output with the Compiler Explorer <\/a>and GCC.<\/p>\n
\"LambdaCaptureThisWarning\"<\/p>\n
 <\/p>\n
The two missing lambdas features of C++20 sound not so thrilling: Lambdas in C++20 can be default-constructed and support copy-assignment when they have no state. Lambdas can be used in unevaluated contexts. Before I present both features together, I have to make a detour: What does unevaluated context mean?<\/p>\n<\/p>\n
Unevaluated Context<\/h2>\n
The following code snippet has a function declaration and a function definition. <\/p>\n
\n
int<\/span> add1<\/span>(int<\/span>, int<\/span>);                       \/\/ declaration<\/span>\r\nint<\/span> add2<\/span>(int<\/span> a, int<\/span> b) { return<\/span> a +<\/span> b; }  \/\/ definition<\/span>\r\n   \r\n<\/pre>\n<\/div>\n
 <\/p>\n
add1<\/span> declares a function, but add2<\/span> defines it. This means if you use add1<\/span> in an evaluated context, such as invoking it, you get a link-time error. The critical observation is that you can use add1<\/span> in unevaluated contexts such as typeid<\/span>, or decltype<\/span>. Both operators accept unevaluated operands.<\/p>\n
 <\/p>\n
\n
\/\/ unevaluatedContext.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo>  <\/span>\/\/ typeid<\/span>\r\n\r\nint<\/span> add1<\/span>(int<\/span>, int<\/span>);                       \/\/ declaration<\/span>\r\nint<\/span> add2<\/span>(int<\/span> a, int<\/span> b) { return<\/span> a +<\/span> b; }  \/\/ definition<\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>cout <<<\/span> \"typeid(add1).name(): \"<\/span> <<<\/span> typeid<\/span>(add1).name() <<<\/span> std::<\/span>endl; \/\/ (1)<\/span>\r\n    \r\n    decltype(*<\/span>add1) add =<\/span> add2;                                               \/\/ (2)<\/span>\r\n    \r\n    std::<\/span>cout <<<\/span> \"add(2000, 20): \"<\/span> <<<\/span> add(2000<\/span>, 20<\/span>) <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
typeid(add1).name()<\/span> (1) returns a string representation of the type, and decltype<\/span> (2) deduces the type of its argument.<\/p>\n
 \"unevaluatedContext\"<\/p>\n
Stateless Lambdas can be default-constructed and copy-assigned<\/h2>\n
Lambdas can be used in unevaluated contexts<\/h2>\n
Admittedly, this is quite a long title. Maybe the term stateless lambda is new to you. A stateless lambda is a lambda that captures nothing from its environment. Or, to put it the other way around. A stateless lambda is a lambda where the initial brackets []<\/span> in the lambda definition are empty. For example, the lambda expression auto add = [ ](int a, int b) { return a + b; }; <\/span>is stateless.<\/p>\n
When you combine the features, you get lambdas, which are pretty handy. <\/p>\n
Before I show you the example, I must add a few remarks. std::set<\/span> such as all other ordered associative containers from the standard template library  (std::map, std::multiset<\/span>,  and std::multimap<\/span>) use per-default std::less<\/span> to sort the keys. std::less<\/span> guarantees that all keys are ordered lexicographically in ascending order. The declaration of std::set<\/span>  on cppreference.com<\/a> shows you this ordering behavior.<\/p>\n
<\/p>\n
\n
template<\/span><<\/span>\r\n    class<\/span> Key<\/span>,\r\n    class<\/span> Compare<\/span> =<\/span> std::<\/span>less<<\/span>Key><\/span>,\r\n    class<\/span> Allocator<\/span> =<\/span> std::<\/span>allocator<<\/span>Key><\/span>\r\n><\/span> class<\/span> set<\/span>;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Now, let me play with the ordering in the following example.<\/p>\n
 <\/p>\n
\n
\/\/ lambdaUnevaluatedContext.cpp<\/span>\r\n\r\n#include <cmath><\/span>\r\n#include <iostream><\/span>\r\n#include <memory><\/span>\r\n#include <set><\/span>\r\n#include <string><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont><\/span>\r\nvoid<\/span> printContainer(const<\/span> Cont&<\/span> cont) {\r\n    for<\/span> (const<\/span> auto<\/span>&<\/span> c:<\/span> cont) std::<\/span>cout <<<\/span> c <<<\/span> \"  \"<\/span>;\r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>\"<\/span>;\r\n}\r\n\r\nint<\/span> main() {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>set<<\/span>std::<\/span>string><\/span> set1 =<\/span> {\"scott\"<\/span>, \"Bjarne\"<\/span>, \"Herb\"<\/span>, \"Dave\"<\/span>, \"michael\"<\/span>};\r\n    printContainer(set1);\r\n    \r\n    using<\/span> SetDecreasing =<\/span> std::<\/span>set<<\/span>std::<\/span>string, decltype([](const<\/span> auto<\/span>&<\/span> l, const<\/span> auto<\/span>&<\/span> r){ return<\/span> l ><\/span> r; })><\/span>;           \/\/ (1)<\/span>\r\n    SetDecreasing set2 =<\/span> {\"scott\"<\/span>, \"Bjarne\"<\/span>, \"Herb\"<\/span>, \"Dave\"<\/span>, \"michael\"<\/span>};\r\n    printContainer(set2);     \/\/ (2)<\/span>\r\n\r\n    using<\/span> SetLength =<\/span> std::<\/span>set<<\/span>std::<\/span>string, decltype([](const<\/span> auto<\/span>&<\/span> l, const<\/span> auto<\/span>&<\/span> r){ return<\/span> l.size() <<\/span> r.size(); })><\/span>; \/\/ (1)<\/span>\r\n    SetLength set3 =<\/span> {\"scott\"<\/span>, \"Bjarne\"<\/span>, \"Herb\"<\/span>, \"Dave\"<\/span>, \"michael\"<\/span>};\r\n    printContainer(set3);     \/\/ (2)<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>set<<\/span>int<\/span>><\/span> set4 =<\/span> {-<\/span>10<\/span>, 5<\/span>, 3<\/span>, 100<\/span>, 0<\/span>, -<\/span>25<\/span>};\r\n    printContainer(set4);\r\n\r\n    using<\/span> setAbsolute =<\/span> std::<\/span>set<<\/span>int<\/span>, decltype([](const<\/span> auto<\/span>&<\/span> l, const<\/span> auto<\/span>&<\/span> r){ return<\/span>  std::<\/span>abs(l)<<\/span> std::<\/span>abs(r); })><\/span>; \/\/ (1)<\/span>\r\n    setAbsolute set5 =<\/span> {-<\/span>10<\/span>, 5<\/span>, 3<\/span>, 100<\/span>, 0<\/span>, -<\/span>25<\/span>};\r\n    printContainer(set5);    \/\/ (2)<\/span>\r\n    \r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n    \r\n}\r\n \r\n<\/pre>\n<\/div>\n
 <\/p>\n
set1<\/span> and set4<\/span> sort their keys in ascending order. set2<\/span>, set3<\/span>, and set5<\/span> uniquely use a lambda in an unevaluated context. The using<\/span> keyword (1) declares a type alias, which is used in the following line (2) to define the sets. Creating the set causes the call of the default constructor of the stateless lambda.<\/p>\n
Thanks to the Compiler Explorer and GCC, here is the program’s output.<\/p>\n
 \"lambdaUnevaluatedContext\"<\/p>\n
When you study the output of the program, you may be surprised. The special set3, which uses the lambda [](const auto& l, const auto& r){ return l.size() < r.size(); } <\/span>as a predicate, ignores the name “Dave”. <\/span>The reason is simple. “Dave<\/span>” has the same size as “Herb<\/span>“, which was added first. std::set<\/span> supports unique keys, and the keys are identical using the special predicate. If I had used std::multiset, <\/span>this wouldn’t have happened.<\/p>\n
What’s next?<\/h2>\n
Only a few smaller features in C++20 are left. The little features include the new attributes [[likely]<\/span>] and [[unlikely]]<\/span>, and most of volatile<\/span> was deprecated.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Lambdas in C++20 can be default-constructed and support copy-assignment when they have no state. Lambdas can be used in unevaluated contexts. Additionally, they detect when you implicitly copy the this pointer. This means a significant cause of undefined behavior with lambdas is gone.<\/p>\n","protected":false},"author":21,"featured_media":5945,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[459],"class_list":["post-5958","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-lambdas"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5958","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=5958"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5958\/revisions"}],"predecessor-version":[{"id":6731,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5958\/revisions\/6731"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5945"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5958"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5958"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5958"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}