What is the type deduction mechanism for lambda expressions in C++ functions?

When a lambda expression captures a variable from an enclosing scope, the return type is deduced to the type of the captured variable. If multiple variables are captured, the return type is jointly deduced from their types. This mechanism allows the return type of a lambda expression to be deduced and automatically handles different types of containers when needed.

Type derivation mechanism of lambda expression in C function

Lambda expression is a convenient way to define anonymous functions in C method. This expression allows type deduction within a function for its return type.

Type deduction mechanism

When a lambda expression captures a variable from its enclosing scope, the deduced return type will be the same as the type of the captured variable. For example:

int main() {
  int x = 10;
  auto lambda = [x] { return x; };
  int result = lambda();
}

In this example, the lambda expression captures the variable x, so its return type is deduced to be int, and it can be stored in int variable.

If multiple variables are captured

If a lambda expression captures multiple variables, its return type will be jointly deduced from the types of the captured variables. For example:

struct Point {
  int x;
  int y;
};

int main() {
  Point point = {1, 2};
  auto lambda = [point] { return point.x + point.y; };
  int result = lambda();
}

In this example, the lambda expression captures an instance point of the structure Point, so its return type is deduced to be int and can be stored in a int variable.

Practical Case

The following is a good practical case showing the type derivation of lambda expressions:

#include <iostream>
#include <vector>

template <typename T>
void print_vector(const std::vector<T>& v) {
  for (auto& element : v) {
    std::cout << element << " ";
  }
  std::cout << std::endl;
}

int main() {
  std::vector<int> v1 = {1, 2, 3};
  std::vector<double> v2 = {1.5, 2.5, 3.5};

  print_vector(v1);
  print_vector(v2);
}

In this example, # The ##print_vector function uses lambda expressions to deduce the T type and automatically handles different types of containers. This function will type infer the correct return type and allow printing out the contents of the container of different types.

The above is the detailed content of What is the type deduction mechanism for lambda expressions in C++ functions?. For more information, please follow other related articles on the PHP Chinese website!