C++ Lambda表达式：捕获子句与参数列表的核心差异是什么？

Hey Reza, great question—since you’re already up to speed on the syntax rules, let’s cut straight to the practical utility and core design differences between captures and arguments, plus when to reach for each.

Why Use Captures? #

Captures exist to bind variables from the scope where your lambda is defined (its "context") into the lambda’s body. Their key advantages are:

• Seamless integration with fixed-interface callbacks: Many STL algorithms (like std::for_each, std::sort, or std::find_if) expect callables with a specific parameter signature. If you need to use a variable from your surrounding code that doesn’t fit that signature, captures are your only clean option. For example:

  std::vector<std::string> words = {"apple", "banana", "cherry"};
  size_t min_length = 6;
  // std::find_if expects a unary predicate (takes one string, returns bool)
  auto long_word = std::find_if(words.begin(), words.end(), [min_length](const std::string& word) {
      return word.size() >= min_length;
  });
  

  Here, we can’t pass min_length as an argument to the predicate—capturing it lets us inject our context into the fixed callback interface.

• Preserve context for repeated calls: If a lambda will be invoked multiple times with the same "environmental" variable, capturing it avoids redundant parameter passing. Instead of writing my_lambda(x, fixed_val) every time, you capture fixed_val once and just call my_lambda(x).

• Capture-by-value for snapshotting: When you capture a variable by value ([x]), you get a copy of its value at the moment the lambda is defined. This is perfect for creating lambdas that "remember" a state from their creation time—like in loops where you want each lambda to hold the current iteration’s value, not a reference to a changing loop variable.

Why Use Arguments? #

Arguments are the traditional way to pass values to a callable at invocation time, and they shine in these scenarios:

• Flexibility for variable input: If your lambda needs to accept different values each time it’s called, arguments are the right choice. For example, a reusable arithmetic lambda makes far more sense with arguments than captures:

  auto add = [](int a, int b) { return a + b; };
  int sum1 = add(2, 3);  // 5
  int sum2 = add(10, 20); // 30
  

  Capturing a and b would force you to redefine the lambda every time you want to add different numbers—cumbersome and unnecessary.

• Explicit dependency clarity: Arguments make your lambda’s required inputs obvious at a glance. Anyone reading your code can look at the lambda’s signature ((int a, int b)) and immediately know what it needs to run. Captures, by contrast, are implicit—you have to scan the surrounding scope to find where captured variables come from.

• Avoid lifecycle risks: Capturing references or pointers ([&x], [&ptr]) introduces the risk of dangling references if the captured variable goes out of scope before the lambda is called. Arguments don’t have this problem: since they’re passed at invocation time, you only need to ensure the argument is valid during the call itself.

• Generic, context-agnostic lambdas: If you want a lambda that’s reusable across different scopes (like a utility function), arguments keep it decoupled from any specific surrounding context. Captures tie the lambda to the scope where it was defined, making it less portable.

Quick Under-the-Hood Context #

To reinforce the difference:

• When you capture a variable, the compiler generates an anonymous "closure class" where the captured variable becomes a member. The lambda’s operator() uses these members. Value captures are copied when the closure is created; reference captures store a reference/pointer.
• Arguments are just parameters to the lambda’s operator()—they behave exactly like parameters in a regular function, passed in at call time and discarded afterward.

Rule of Thumb #

• Use captures when the variable is part of the lambda’s definition-time context, or when you need to adapt the lambda to a fixed callback interface.
• Use arguments when the variable is a dynamic input that changes per call, or when you want explicit, clear dependencies for your lambda.

内容的提问来源于stack exchange，提问作者Reza