Lambda expressions are a convenient way to write inline functions in C, especially for passing small logic as parameters to other functions, such as functions in STL algorithms. Its basic syntax includes capture list (in square brackets), parameter list (optional) and function body (in curly brackets), such as: [capture](parameters) -> return_type { // function body}. 1. The capture list specifies the external variables that the lambda can access and its access method, such as [x] captured by value, [&x] captured by reference; 2. The return type can be omitted, and if the function body contains only one return statement, it will be derived by the compiler; 3. Use the mutable keyword to modify the variables captured by value; 4. Common uses include combined with STL algorithms, such as predicates or operations in std::remove_if or std::sort; 5. Lambda is suitable for short, one-time logic, and complex or multiplexed logic should use ordinary functions or functors. It is recommended to keep lambda concise, avoid excessive capture of variables, and use reference capture with caution to prevent dangling references.

Lambda expressions in Ca 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 multiples 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 predictates 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 function.

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.

The above is the detailed content of C tutorial on lambda expressions. For more information, please follow other related articles on the PHP Chinese website!