Cpp - Function Lambda Expressions


A lambda expressions create inline anonymous functions.

Here's an example:

auto my_lambda = [](){ std::cout << "this is a test!" << std::endl; }; 

This code produces the following output:

this is a test! 

The anonymous function executes the code between the { and } braces.

There's a semi-colon at the end of the line following the } brace.

The function is stored in the variable my_lambda and run using the same syntax as calling a function.

The lambda expression can have one or more arguments, which are specified within the parenthesis marks after the [ ] square brackets.

This example has two arguments:

auto multiply = [](int x, int y){ std::cout << "Total: " << x * y << std::endl; }; 
multiply(5, 5); 

Here's the output:

Total: 25

When a lambda expression has no arguments, the parentheses can be left out of the expression.

The first example didn't have parameters, so the following code removed the parentheses:

auto my_lambda = []{ std::cout << "this is a test!" << std::endl; }; 

The expression can return a value by specifying its return type (or auto) after a -> operator.

Here's a rewrite of the previous example that returns the sum of multiplying x and y.

auto multiply = [](int x, int y) -> int { return x * y; }; 
int sum = multiply(7, 17); 
std::cout << "Total: " << sum << std::endl; 

A lambda expression normally does not have access to the outside variables.

To reference the outside variables use [ ] square brackets, which are called the capture block.

List the variables inside the [ and ] brackets separated by commas.

int x = 7; 
auto multiply = [x](int y) -> int { return x * y; }; 
int sum = multiply(17); 
std::cout << "Total: " << sum << std::endl;