Difference between C ++ 0x lambdas and operator (), closure and functor

Question

I am sure that I get the general meaning of the constructions, but I do not see their purpose in C ++. I read previous related posts here at SO and elsewhere, but I don't understand why they should be a new language feature.

What I would like to answer in this way

• What is the difference between a lambda argument and a template taking a function / functor.

• Is a closure just a functor with some given state of an object (scope?)?

• What is the killer app for these designs? or perhaps a typical use case?

Answer 1

Lambdas is really just syntactic sugar for a functor. You can do everything yourself: define a new class, add member variables to store the captured values ​​and references, connect them in the constructor, write operator()() and finally create an instance and pass it. Or you can use a lambda that has 1/10 of the code and works the same.

Lambdas that are not captured can be converted to function pointers. All lambdas can be converted to std::function or get their own unique type, which works well in template algorithms that accept a functor.

Answer 2

Well, you are really asking a few questions, perhaps because you are not completely familiar with the terminology. I will try to answer everyone.

What is the difference between lambda and "operator ()"? - Let me rewrite it like this: "What is the difference between a lambda and an object using the operator ()?"

In principle, nothing. The main difference is that the lambda expression creates a functional object, while the object with the () IS operator is a functional object. The end result is similar enough to consider the same thing, but an object that can be called with syntax (params).

What is the difference between a closure and a functor? This is also quite confusing. Follow this link:

http://en.wikipedia.org/wiki/Closure_(computer_programming) http://en.wikipedia.org/wiki/Closure_(computer_programming)#C.2B.2B

So, as you can see, closure is a kind of “functor” that is defined within such an area that it absorbs the variables available to it within this area. In other words, its function, which is built on the fly, while the program is running and that the construction process is parameterized by the runtime values ​​of the region containing it. So, in C ++, closures are lambdas that use values ​​inside a function to build lambdas.

What is the difference between a lambda argument and a template taking a function / functor? - This is embarrassing again. The difference is that they are nothing alike. The "argument" template, which takes a function / functor, is already a confusing wording, so I assume that "argument" means "function" because the arguments take nothing. In this case, although a lambda can accept a functor as an argument, it cannot be a template, alone. Two, typically a lambda, is one that is passed as an argument to a function that takes a functor argument.

Is a closure just a functor with some status of the object's object (scope?)?

As can be seen from the above link, no. In fact, in fact, closing does not even have a state. A closure is built on the basis of the state of some other entity that built it inside this functor, although this is not a state, it is the construction of the object itself.

What is the killer app for these designs? or perhaps a typical use case?

I change my mind: "Why are these things useful?"

Well, in general, the ability to treat any object as a function, if it has an operator (), is extremely useful for an entire array of things. Firstly, this allows us to extend the behavior of any stdlib algorithm using either objects or free functions. It is impossible to destroy the enormous utility that it has.

Speaking specifically about lambda expressions, they simply simplify the process. The restrictions imposed by object definitions, in some cases, somewhat complicated the use of stdlib algorithms (from the point of view of using development rather than program efficiency). First, at a time when at least any object passed as a parameter to the template must be defined externally. I believe that change, but still ... creating whole objects just to accomplish the basic things that are used in only one place is inconvenient. Lambda expressions allow this definition to be fairly simple, within the place of its use, etc. Etc.