Lambda表達(dá)式在C 中是一種編寫內(nèi)聯(lián)函數(shù)的便捷方式，特別適用于將小型邏輯作為參數(shù)傳遞給其他函數(shù)，如STL算法中的函數(shù)。其基本語法包括捕獲列表（方括號內(nèi)）、參數(shù)列表（可選）和函數(shù)體（花括號內(nèi)），例如：[capture](parameters) -> return_type { // function body}。1. 捕獲列表指定lambda可訪問的外部變量及其訪問方式，如[x]按值捕獲，[&x]按引用捕獲；2. 返回類型可省略，若函數(shù)體僅含一個(gè)返回語句則由編譯器推導(dǎo)；3. 使用mutable關(guān)鍵字可修改按值捕獲的變量；4. 常見用途包括與STL算法結(jié)合使用，如std::remove_if或std::sort中的謂詞或操作；5. lambda適用于簡短、一次性使用的邏輯，復(fù)雜或需復(fù)用的邏輯應(yīng)使用普通函數(shù)或函子。建議保持lambda簡潔、避免過多捕獲變量、謹(jǐn)慎使用引用捕獲以防止懸空引用。

Lambda expressions in C are a convenient way to write inline functions — especially useful when passing small bits of logic as arguments to other functions, like those in the STL algorithms. If you've seen code with square brackets and =>, and wondered what's going on, this tutorial should clear things up.

Basic Syntax of a Lambda

A lambda expression starts with a capture clause (in square brackets), followed by parameter list (optional), then the body inside curly braces.

Here's the general structure:

[capture](parameters) -> return_type {
    // function body
}

You don’t always have to specify the return type — the compiler can deduce it if the body has a simple return statement.

For example:

auto multiply = [](int a, int b) {
    return a * b;
};

This creates a lambda that multiplies two integers and stores it in a variable called multiply. You can call it like a regular function: multiply(3, 4) returns 12.

Capturing Variables from the Surrounding Scope

The capture clause tells the lambda which variables from the outer scope it can access, and how (by value or reference).

• [x] captures x by value (copy)
• [&x] captures x by reference
• [&] captures everything used by reference
• [=] captures everything used by value

Example:

int offset = 5;
auto addOffset = [offset](int value) {
    return value   offset;
};

In this case, offset is copied into the lambda. Modifying offset later won't affect the value inside the lambda.

If you want to change captured values by value, you need to mark the lambda mutable:

int count = 0;
auto increment = [count]() mutable {
    return   count;
};

Now each call to increment() increases its own copy of count.

Using Lambdas with STL Algorithms

One of the most common uses for lambdas is as predicates or operations in STL algorithms.

Say you have a vector of numbers and you want to remove all even numbers:

std::vector<int> numbers = {1, 2, 3, 4, 5, 6};

numbers.erase(
    std::remove_if(numbers.begin(), numbers.end(), [](int n) {
        return n % 2 == 0;
    }),
    numbers.end()
);

Here, the lambda checks if a number is even and returns true for those to be removed. It’s short, self-contained, and avoids having to define a separate function.

Another common use is sorting with custom logic:

std::vector<std::string> names = {"Zoe", "Alice", "Bob"};
std::sort(names.begin(), names.end(), [](const std::string& a, const std::string& b) {
    return a.length() < b.length();
});

This sorts the strings based on their length instead of alphabetical order.

When to Use Lambdas vs Regular Functions

Lambdas are best for small, one-off pieces of logic that don’t need reuse. They make your code more readable when the logic is tightly coupled with another operation.

On the other hand, if the logic is complex or reused across multiple places, stick with a normal function or functor.

Some tips:

• Keep lambdas short and focused
• Avoid capturing too many variables unless necessary
• Use mutable only when you really need to modify copies
• Prefer capturing by reference only when needed — otherwise prefer by value to avoid dangling references

That's the core of working with lambdas in C . They're powerful but easy to overdo — use them where they simplify code without making it harder to follow.基本上就這些。

以上是c lambda表達(dá)式教程的詳細(xì)內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！