What is the difference between C++ Lambda expressions and traditional functions?

C++ Differences between Lambda expressions and traditional functions The main differences between Lambda expressions and traditional functions include: Anonymity: Lambda expressions are anonymous and do not require a function name. Syntax: Lambda expressions are expressed using square brackets and parentheses, and traditional functions use standard function syntax. Capture lists: Lambda expressions can access external variables using capture lists, whereas traditional functions can only access explicitly passed arguments. Type inference: Lambda expressions support type inference, whereas traditional functions require an explicit type.

The difference between C++ Lambda expressions and traditional functions

Introduction

Lambda Expression is a powerful anonymous function introduced in C++, which has similar functions to traditional functions, but has a simpler syntax. This article explores the key differences between lambda expressions and traditional functions and provides practical examples to illustrate these differences.

Anonymity

One of the main differences is that lambda expressions are anonymous, meaning they have no name. In contrast, traditional functions require a name to be declared before they can be called.

Syntax

Lambda expressions are expressed using square brackets and parentheses, as shown below:

[capture-list] (parameters) -> return-type { function-body };

Traditional functions use the following syntax:

return-type function-name(parameters) { function-body };

Capture list

lambda expressions can use a capture list, which allows access to variables in the outer scope. Traditional functions cannot access external variables unless passed to them explicitly.

Type inference

lambda expressions support type inference, which means the compiler can automatically infer the return type and parameter types of the lambda. Traditional functions require an explicit type specification.

Practical case

Example 1: Sorting vectors

Use lambda expressions to sort integer vectors in ascending order:

#include <vector>
#include <algorithm>

int main() {
  std::vector<int> v = {3, 1, 4, 2};

  std::sort(v.begin(), v.end(), [](int a, int b) { return a < b; });

  for (int num : v) {
    std::cout << num << " ";
  }
  std::cout << std::endl;

  return 0;
}

Example 2: Calculate the average

Use lambda expression to calculate the average of a vector of floating point numbers:

#include <vector>
#include <numeric>

int main() {
  std::vector<float> v = {2.5, 3.1, 4.2, 1.7};

  float avg = std::accumulate(v.begin(), v.end(), 0.0, [](float a, float b) { return a + b; }) / v.size();

  std::cout << "Average: " << avg << std::endl;

  return 0;
}

Conclusion

Lambda expressions have similarities and differences with traditional functions. Lambda expressions are anonymous, type-inferred, and allow capture of external variables, providing a more concise and flexible way of writing functions. Lambda expressions are a great choice for scenarios where you need to quickly create one-off functions or handle external variables.

The above is the detailed content of What is the difference between C++ Lambda expressions and traditional functions?. For more information, please follow other related articles on the PHP Chinese website!