In C++11, is "lambda function" same with "lambda expression" and "closure"? - c++

Question

On cppreference website，when talking about direct_initialization, it says it works in closure parameter capture like...{...}
I think this should be "lambda function", but why it's also called "closure"?
I checked C++11 standard, the item "closure" first appeared in section 5.1.2 (lambda expression)，which says:
The evaluation of a lambda-expression results in a prvalue temporary (12.2). This temporary is called the
closure object. A lambda-expression shall not appear in an unevaluated operand (Clause 5). [ Note: A
closure object behaves like a function object (20.8). — end note ]
So how to understand "evalute lamdba expression"? It this "evaluation" something happened during compilation or runtime?
Is there differences in C++11, among the items "lambda expression", "lambda function", and "closure"?
I'm not talking about other programming languages like Closure, just focus on C++11.
Thanks.

Answer 1

What is a closure (quoting from wikipedia):
In programming languages, closures (also lexical closures or function
closures) are a technique for implementing lexically scoped name
binding in languages with first-class functions. Operationally, a
closure is a record storing a function[a] together with an
environment: a mapping associating each free variable of
the function (variables that are used locally, but defined in an
enclosing scope) with the value or storage location to which the name
was bound when the closure was created[b]. A closure,
unlike a plain function, allows the function to access those captured
variables through the closure's reference to them, even when the
function is invoked outside their scope.
[a] The function may be stored as a reference to a function,
such as a function pointer.
[b] These names most frequently refer to values, mutable
variables, or functions, but can also be other entities such as
constants, types, classes, or labels.
What is a lambda expression (quoting from wikipedia):
In computer programming, an anonymous function (function literal,
lambda abstraction) is a function definition that is not bound to an
identifier.
Since C++11, C++ supports anonymous functions, called lambda
expressions, which have the form:
[capture](parameters) -> return_type { function_body }
An example lambda function is defined as follows:
[](int x, int y) -> int { return x + y; }
Since C++11, C++ also supports closures. Closures are defined between
square brackets [and] in the declaration of lambda expression. The
mechanism allows these variables to be captured by value or by
reference. The following table demonstrates this:
[] //no variables defined. Attempting to use any external variables in the lambda is an error.
[x, &y] //x is captured by value, y is captured by reference
[&] //any external variable is implicitly captured by reference if used
[=] //any external variable is implicitly captured by value if used
[&, x] //x is explicitly captured by value. Other variables will be captured by reference
[=, &z] //z is explicitly captured by reference. Other variables will be captured by value
Résumé
Terms Lambda expression and Lambda function are used interchangeably for signifying the definition/declaration of an anonymous function object as:
[capture](parameters) -> return_type { function_body }
With the term closure we refer to the run-time function object created by the evaluation of a lambda expression.
Now for lambdas to be evaluated at compile time, this would require a lambda to be a constant expression. Unfortunately, lambdas aren't constexpr and as such can't be evaluated at compile time. However, there's a proposal submitted to the committee N4487 that suggests that with the lifting of some restrictions we could have constexpr lambdas. That is, in the future we might have constexpr lambdas that could be evaluated at compile time.

Answer 2

Lambda expression is like other expressions, being evaluated at runtime by default. Evaluating the expression 1 + 2 gives a int which value is 3. Evaluating the lambda expression [] { return 0; } gives a closure object, which is also a function object, which operator()() is a function that returns 0.
In short, a closure object is a runtime object, like any other objects in C++, a lambda expression is a expression which result is a closure object.