{"id":246,"date":"2017-05-11T18:18:02","date_gmt":"2017-05-11T18:18:02","guid":{"rendered":"http:\/\/imalogic.com\/blog\/?p=246"},"modified":"2017-05-12T12:42:08","modified_gmt":"2017-05-12T12:42:08","slug":"c11-why-lambdas-rock","status":"publish","type":"post","link":"https:\/\/imalogic.com\/blog\/2017\/05\/11\/c11-why-lambdas-rock\/","title":{"rendered":"C++11 – Why Lambdas Rock"},"content":{"rendered":"
<\/p>\n
The problem<\/h2>\n
C++ includes useful generic functions like std::for_each<\/code> and std::transform<\/code>, which can be very handy. Unfortunately they can also be quite cumbersome to use, particularly if the functor<\/a> you would like to apply is unique to the particular function.<\/p>\n
#include<\/span> <algorithm><\/span>\r\n#include<\/span> <vector><\/span>\r\n\r\nnamespace<\/span> {<\/span>\r\n  struct<\/span> f <\/span>{<\/span>\r\n    void<\/span> operator<\/span>()(<\/span>int<\/span>)<\/span> {<\/span>\r\n      \/\/ do something<\/span>\r\n    }<\/span>\r\n  };<\/span>\r\n}<\/span>\r\n\r\nvoid<\/span> func<\/span>(<\/span>std<\/span>::<\/span>vector<\/span><int><\/span>&<\/span> v<\/span>)<\/span> {<\/span>\r\n  f f<\/span>;<\/span>\r\n  std<\/span>::<\/span>for_each<\/span>(<\/span>v<\/span>.<\/span>begin<\/span>(),<\/span> v<\/span>.<\/span>end<\/span>(),<\/span> f<\/span>);<\/span>\r\n}<\/span><\/code><\/pre>\nIf you only use f once and in that specific place it seems overkill to be writing a whole class just to do something trivial and one off.<\/p>\n
In C++03 you might be tempted to write something like the following, to keep the functor local:<\/p>\nvoid<\/span> func2<\/span>(<\/span>std<\/span>::<\/span>vector<\/span><int><\/span>&<\/span> v<\/span>)<\/span> {<\/span>\r\n  struct<\/span> {<\/span>\r\n    void<\/span> operator<\/span>()(<\/span>int<\/span>)<\/span> {<\/span>\r\n       \/\/ do something<\/span>\r\n    }<\/span>\r\n  }<\/span> f<\/span>;<\/span>\r\n  std<\/span>::<\/span>for_each<\/span>(<\/span>v<\/span>.<\/span>begin<\/span>(),<\/span> v<\/span>.<\/span>end<\/span>(),<\/span> f<\/span>);<\/span>\r\n}<\/span><\/code><\/pre>\nhowever this is not allowed, f<\/code> cannot be passed to a template function in C++03.<\/p>\nThe new solution<\/h2>\nC++11 introduces lambdas allow you to write an inline, anonymous functor to replace the struct f<\/code>. For small simple examples this can be cleaner to read (it keeps everything in one place) and potentially simpler to maintain, for example in the simplest form:<\/p>\nvoid<\/span> func3<\/span>(<\/span>std<\/span>::<\/span>vector<\/span><int><\/span>&<\/span> v<\/span>)<\/span> {<\/span>\r\n  std<\/span>::<\/span>for_each<\/span>(<\/span>v<\/span>.<\/span>begin<\/span>(),<\/span> v<\/span>.<\/span>end<\/span>(),<\/span> [](<\/span>int<\/span>)<\/span> {<\/span> \/* do something here*\/<\/span> });<\/span>\r\n}<\/span><\/code><\/pre>\nLambda functions are just syntactic sugar for anonymous functors.<\/p>\nBasic Lambda Syntax<\/a><\/h2>\n\u00a0<\/p>\n
Let\u2019s see the really basic syntax for lambda.<\/p>\n
\u00a0<\/p>\n#include <iostream>\r\n\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\n    auto func = [] () { cout << \"Hello world\"; };\r\n    func(); \/\/ now call the function\r\n}<\/pre>\nThe identifier [ ], called the capture specification, tells the compiler we\u2019re creating a lambda function. You\u2019ll see this (or a variant) at the start of every lambda function.<\/p>\n<\/a><\/p>\n
Next up, like any other function, we need an argument list: (). Where is the return value? Turns out that we don\u2019t need to give one. In C++11, if the compiler can deduce the return value of the lambda function, it will do it rather than force you to include it. In this case, the compiler knows the function returns nothing. Next we have the body, printing out \u201cHello World\u201d. This line of code doesn\u2019t actually cause anything to print out though\u2013we\u2019re just creating the function here. It\u2019s almost like defining a normal function\u2013it just happens to be inline with the rest of the code.<\/p>\n
It\u2019s only on the next line that we call the lambda function: func() \u2014 it looks just like calling any other function. By the way, notice how easy this is to do with auto<\/a>! You don\u2019t need to sweat the ugly syntax of a function pointer.<\/p>\n
Variable Capture with Lambdas<\/h2>\nAlthough these kinds of simple uses of lambd are nice, variable capture is the real secret sauce that makes a lambda function great. Let\u2019s imagine that you want to create a small function that finds addresses that contain a specific name. Wouldn\u2019t it be nice if you could write code something like this?<\/p>\n
AdressBook global_adress_book;\r\n\/\/ read in the name from a user, which we want to search\r\nstring name;\r\ncin>> name;\r\nreturn global_address_book.findMatchingAddresses( \r\n    \/\/ notice that the lambda function uses the the variable 'name'\r\n    [&] (const string& addr) { return addr.find( name ) != string::npos; } \r\n);\r\n<\/pre>\nIt turns out that this example is completely legal\u2013and it shows the real value of lambda. We\u2019re able to take a variable declared outside of the lambda (name), and use it inside of the lambda. When findMatchingAddresses calls our lambda function, all the code inside of it executes\u2013and when addr.find is called, it has access to the name that the user passed in. The only thing we needed to do to make it work is tell the compiler we wanted to have variable capture. I did that by putting [&] for the capture specification, rather than []. The empty [] tells the compiler not to capture any variables, whereas the [&] specification tells the compiler to perform variable capture.<\/p>\n
Return Values<\/h3>\nBy default, if your lambda does not have a return statement, it defaults to void. If you have a simple return expression, the compiler will deduce the type of the return value:<\/p>\n
[] () { return 1; } \/\/ compiler knows this returns an integer<\/pre>\n[] () -> int { return 1; } \/\/ now we're telling the compiler what we want<\/pre>\nHow are Lambda Closures Implemented ?<\/h2>\n\n[] Capture nothing (or, a scorched earth strategy?)<\/li>\n
[&] Capture any referenced variable by reference<\/li>\n
[=] Capture any referenced variable by making a copy<\/li>\n
[=, &foo] Capture any referenced variable by making a copy, but capture variable foo by reference<\/li>\n
[bar] Capture bar by making a copy; don\u2019t copy anything else<\/li>\n
[this] Capture the this pointer of the enclosing class<\/li>\n<\/ul>\nA Note About Function Pointers<\/h3>\ntypedef int (*func)();\r\nfunc f = [] () -> int { return 2; };\r\nf();<\/pre>\n<\/p>\n<\/body>","protected":false},"excerpt":{"rendered":"
The problem C++ includes useful generic functions like std::for_each and std::transform, which can be very handy. Unfortunately they can also<\/p>\n","protected":false},"author":1,"featured_media":271,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[7],"tags":[24,26,27],"class_list":["post-246","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-coding","tag-c","tag-code","tag-programming"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/imalogic.com\/blog\/wp-content\/uploads\/2017\/05\/lambda.png?fit=204%2C300&ssl=1","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p8J21V-3Y","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/posts\/246","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/comments?post=246"}],"version-history":[{"count":2,"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/posts\/246\/revisions"}],"predecessor-version":[{"id":276,"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/posts\/246\/revisions\/276"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/media\/271"}],"wp:attachment":[{"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/media?parent=246"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/categories?post=246"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/imalogic.com\/blog\/wp-json\/wp\/v2\/tags?post=246"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}