In C, the lambda capture clause controls how external variables are introduced into the lambda function through values, references, or default patterns. 1. The capture list is at the beginning of the lambda expression and is used to capture variables in the external scope for internal use of the lambda. 2. Capture through value ([var]) will copy the variable. Modification in the lambda will not affect the original variable. If you need to modify the copy, you need to use the mutable keyword. 3. By reference capture ([&var]) allows lambda to directly modify the original variable, but there is a risk of dangling references. 4. Default capture mode [=] automatically captures all used variables by value, [&] automatically captures by reference, but should be used with caution to avoid potential errors. 5. You can use a mix of specific captures with default captures, such as [=, &x] or [&, x], but the same variable cannot be captured repeatedly and may affect the readability of the code. 6. When choosing a capture method, you should weigh performance and behavior based on your needs to avoid unnecessary copying and misuse of default capture.

In C , a lambda capture clause determines how variables from the surrounding scope are made available inside a lambda function. It's the part of the lambda expression enclosed in square brackets [] , and it controls whether those variables are captured by value, by reference, or not at all.

What the Capture Clause Does

The capture clause sits at the very beginning of a lambda expression. Its job is to "capture" (ie, bring into the lambda's scope) variables that exist outside the lambda but are needed for its execution. Without a proper capture clause, you won't be able to access external variables inside your lambda body.

Capturing Variables by Value ( [var] )

When you capture a variable by value, a copy of that variable is stored inside the lambda. This means changes made inside the lambda do not affect the original variable.

For example:

 int x = 10;
auto func = [x]() { std::cout << x; };
x = 20;
func(); // Outputs 10, not 20

Here, x is captured by value, so even after changing x to 20, the lambda still holds the original value (10) when it was created.

If you want to modify the captured copy inside the lambda, you need to add the mutable keyword:

 auto func = [x](int y) mutable {
    x = y;
    std::cout << x;
};

Now, x can be changed within the lambda — but again, only the copy.

Capturing Variables by Reference ( [&var] )

Capturing by reference gives the lambda direct access to the original variable. Any modifications inside the lambda will affect the original variable.

Example:

 int x = 10;
auto func = [&x]() { x = 30; };
func();
std::cout << x; // Outputs 30

This is useful when you want to modify state outside the lambda. But it also introduces risk — if the lambda outlives the variable it references, you end up with a dangling reference.

Default Capture Modes: [=] and [&]

Instead of listing each variable, you can use default capture modes:

• [=] captures all used variables by value
• [&] captures all used variables by reference

These are convenient but should be used carefully. For instance:

 int a = 1, b = 2;
auto func = [=]() { std::cout << ab; };

Here, both a and b are captured by value automatically.

Similarly:

 auto func = [&](int x) { b = x; };

In this case, any referenced variable (like b ) will be captured by reference.

Using default captures can sometimes hide subtle bugs, especially when dealing with long-lived lambdas or complex scopes.

Mixing Specific and Default Captures

You can combine specific and default captures in one clause. For example:

• [=, &x] captures everything by value, but captures x by reference
• [&, x] captures everything by reference, but captures x by value

Just note that once you specify a default capture, you can't re-capture any variable in the same clause. Also, mixing them can make code harder to read unless done intentionally.

A few points to remember:

• You can't have both [=, x] and [&, x] in the same capture list.
• The order doesn't matter — [x, =] is the same as [=, x] .

When to Use Which?

Choosing between capture by value or reference depends on what you're trying to achieve:

• Use capture by value when you want a snapshot of the variable at the time the lambda is created.
• Use capture by reference when you need to reflect changes made inside the lambda back to the original variable.
• Be cautious with [=] and [&] — they're powerful but can lead to unintended behavior if misused.

Also, avoid capturing large objects by value unless necessary — copying them may impact performance.

So yes, lambda capture certificates are pretty straightforward once you understand how they work, but easy to misuse if you're not paying attention.

The above is the detailed content of What is a lambda capture clause in C ?. For more information, please follow other related articles on the PHP Chinese website!