在C 中，lambda捕獲子句通過值、引用或默認模式控制外部變量如何被引入lambda函數(shù)。 1. 捕獲列表位於lambda表達式的開頭，用於捕獲外部作用域中的變量供lambda內(nèi)部使用。 2. 通過值捕獲（[var]）會復制變量，lambda內(nèi)對其修改不影響原變量，若需修改副本需用mutable關鍵字。 3. 通過引用捕獲（[&var]）允許lambda直接修改原變量，但存在懸空引用風險。 4. 默認捕獲模式[=]按值自動捕獲所有使用的變量，[&]按引用自動捕獲，但需謹慎使用以避免潛在錯誤。 5. 可混合使用特定捕獲與默認捕獲，如[=, &x]或[&, x]，但不可重複捕獲同一變量且可能影響代碼可讀性。 6. 選擇捕獲方式應根據(jù)需求權衡性能與行為，避免不必要的複制和誤用默認捕獲。

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 clauses are pretty straightforward once you understand how they work, but easy to misuse if you're not paying attention.

以上是C中的lambda捕獲條款是什麼？的詳細內(nèi)容。更多資訊請關注PHP中文網(wǎng)其他相關文章！