Lambdas in C++0x, Part II

Let's recall the syntax of a lambda expression, from the first part of this post:

  [C](P) M -> R { body }(Q)

  C = capture specification
  P = parameter specification
  M = mutable specification
  R = return type specification
  Q = actual call parameters

Lambda expressions are locally defined functions, also known as anonymous functions. A minimal example could look something like this:

int main()
{
    auto f = []() { std::cout << "hello"; };
    f();
    return 0;
}

The lambda can also be invoked as it is defined, on-the-fly:

[]() { std::cout << "hello"; }();

Here is a lambda that takes an int as argument:

auto fn = [](int x) { std::cout << "x = " << x << "\n"; };
fn(123);

Side note: I tend to use the terms parameter and argument more or less interchangeably. To make things clear, we should, however, make a distinction between the two:

• A parameter is a variable declared in the prototype or declaration of a function.
• The argument is the value that is actually passed to the function.

A return value can be specified, using the trailing return type specification (→ R):

auto fn = [](int x) -> int { return x + 1; };
int n = fn(1);
std::cout << "->" << n << "\n";

The auto keyword saves us some work when the compiler is able to infer the type of an expression automatically. Alternatively, we could write:

std::tr1::function<int(int)> fn = [](int x) -> int { return x + 1; };

In this post, I will continue to examine the capture specification and mutable keyword.