Using Lambdas in Template Functions

When passing a lambda as an argument to a function template, you can use auto as the parameter type. This allows the compiler to deduce the type of the lambda.

Here's an example:

1#include <iostream>
2
3template <typename T, typename Callback>
4void Transform(T& Value, Callback Operation) {
5  Operation(Value);
6}
7
8int main() {
9  int Number{5};
10
11  Transform(Number, [](auto& Value) {  
12    Value *= 2;
13  });
14
15  std::cout << "Number: " << Number << '\n';
16}

1Number: 10

In this case, Transform is a function template that accepts a reference to a value of any type T, and a Callback which is deduced to be the type of the lambda we pass.

Inside main, we pass Number (an int) as the first argument, and a lambda that doubles its argument as the second. The lambda parameter Value is declared as auto&, which allows it to accept arguments of any type by reference.

When Transform is called, the lambda is invoked with Number as its argument, doubling its value.

This pattern is very powerful and flexible. For example, we could easily change the lambda to perform a different operation:

1Transform(Number, [](auto& Value) {
2  Value = Value * Value; // Square the value
3});