What is the motivation behind C++11 lambda expressions?

Question

I am trying to find out if there is an actual computational benefit to using lambda expressions in C++, namely "this code compiles/runs faster/slower because we use lambda expressions" or is it just a neat development perk open for abuse by poor coders trying to look cool?

I understand this question may seem subjective, but I would much appreciate the opinion of the community on this matter.

Answer 1

The benefit is what's the most important thing in writing computer programs: easier to understand code. I'm not aware of any performance considerations.

C++ allows, to a certain extend, to do Functional Programming. Consider this:

std::for_each( begin, end, doer );

The problem with this is that the function (object) doer

1. specifies what's done in the loop
2. yet somewhat hides what's actually done (you have to look up the function object's operator()'s implementation)
3. must be defined in a different scope than the std::for_each call
4. contains a certain amount of boilerplate code
5. is often throw-away code that's not used for anything but this one loop construct

Lambdas considerably improve on all these (and maybe some more I forgot).

Answer 2

I don't think it's nearly as much about the computational performance as increasing the expressive power of the language.

Answer 3

There's no performance benefit per se, but the need for lambda came as a consequence of the wide adoption of the STL and its design ideas.

Specifically, the STL algorithms make frequent use of functors. Without lambda, these functors need to be previously declared to be used. Lambdas make it possible to have 'anonymous', in-place functors.

This is important because there are many situations in which you need to use a functor only once, and you don't want to give a name to it for two reasons: you don't want to pollute the namespace, and in those specific cases the name you give is either vague or extremely long.

I, for instance, use STL a lot, but without C++0x I use much more for() loops than the for_each() algorithm and its cousins. That's because if I were to use for_each() instead, I'd need to get the code from inside the loop and declare a functor for it. Also all the local variables before the loop wouldn't be accessible, so I'd need to write additional code to pass them as parameters to the functor constructor, or another thing equivalent. As a consequence, I tend not to use for_each() unless there's strong motivation, otherwise the code would be longer and more difficult to read.

That's bad, because it's well known that using for_each() and similar algorithms gives much more room to the compiler & the library for optimizations, including automatic parallelism. So, indirectly, lambda will favour more efficient code.

Answer 4

IMO, the most important thing about lambda's is it keeps related code close together. If you have this code:

std::for_each(begin, end, unknown_function);

You need to navigate over to unknown_function to understand what the code does. But with a lambda, the logic can be kept together.