C++11 Lambdas and std::function

Lambda expressions are a highly influential feature introduced in the C++11 standard, allowing developers to define anonymous function objects directly within functions. This capability has greatly simplified the writing of callback functions, registration of event handlers, and the encapsulation of complex logic within algorithm libraries. Unlike traditional std::function usage or manually constructing classes inheriting from std::function, Lambda expressions provide more concise syntax sugar and higher flexibility.

Prior to C++11, to implement a requirement such as "passing an anonymous function," developers typically needed to define a complete struct, overload operators, or pass specific function pointers via template parameters. For example:

struct MyCallback {
    void operator()(int x) const { /* ... */ }
};
MyCallback cb; // Requires manual instantiation

With Lambda expressions, the above logic can be compressed into a single line of code:

auto cb = [](int x) { 
    std::cout << "Value: " << x << std::endl; 
};

This syntax not only reduces boilerplate code but also allows the behavior of function objects to be directly specified at definition time, without requiring additional type declarations.
The core functionality of Lambda expressions lies in their "capture list" (Capture List). Through the [] symbol and its subsequent content, developers decide which variables from the outer scope are accessible within the generated lambda function. This capability makes Lambdas effectively constitute the concept of a "closure" in C++11—an anonymous function object capable of referencing and holding local variables.

The capture list primarily consists of three modes:

Copy Capture [=]: Copies all automatic type variables specified in the list into the lambda internally. This means that even if external variables are modified or destroyed, the lambda retains an independent copy. This is the most commonly used default mode.
```
int x = 10;
auto func = [=]() { std::cout << x; }; // Value of x is 10

x = 20;
func(); // Output: 10 (because a copy was captured by value)
```
Reference Capture [&]: Passes all automatic type variables specified in the list to the lambda by reference. This allows the Lambda to access the latest state of external variables, but requires these variables to remain valid during the execution of the function (i.e., they cannot be destroyed before the function runs).
```
int x = 10;
auto func = [&]() { std::cout << x; }; // Reference capture

x = 20;
func(); // Output: 20 (accessing the latest x)

// ⚠️ Dangerous Example: If the external variable is destroyed before the lambda executes, it results in undefined behavior.
```
Mixed Capture [x, &y]: Allows combining copy capture for certain specific variables (e.g., int z = []() { ... }) while accessing others by reference. This provides great flexibility, allowing developers to precisely control which data needs copying and which requires shared memory addresses.
```
int a = 1, b = 2;
auto func = [a, &b]() { 
    std::cout << "A is: " << a << ", B is: " << b << std::endl; 
};

// Calling again after modifying the external variable; B updates, but A remains at its initial value.
```

Interaction Patterns Between Lambda Expressions and std::function

Although Lambda expressions can themselves be used as function objects (e.g., passed directly to std::sort), std::function provides type erasure and a unified interface when storage, passing, or dynamic binding to different contexts is required. Assigning a Lambda to a std::function variable is a common pattern in C++11/14/17 development, frequently used to implement callback interfaces.

When assigning a specific Lambda expression to std::function:

#include <iostream>
#include <functional>
#include <vector>

int main() {
    std::vector<int> nums = {5, 2, 9, 1};
    
    // Define a specific Lambda for descending order sorting
    auto sortFunc = [](const int& a, const int& b) -> bool { 
        return a > b; 
    };
    
    std::function<void(int&, int&)> swapCallback = [&](int &a, int &b){
        if (a < b) std::swap(a, b); // Complex logic like logging can be included here
    };

    // Lambda can be passed directly to algorithms requiring function objects
    std::sort(nums.begin(), nums.end(), sortFunc); 
    
    return 0;
}

It is worth noting that the assignment operation of std::function possesses type conversion capabilities. If the parameter signature of the passed Lambda does not fully match the target signature of the std::function template parameter (e.g., different return types or capture lists causing internal state differences), the compiler automatically performs an implicit conversion to match the interface. This flexibility makes std::function<T> an ideal container for building generic callback chains, eliminating the need to redefine specific function object structures every time a call is made.

Practical Application Scenarios and Best Practice Recommendations

Lambda expressions are ubiquitous in modern C++ development, with applications ranging from low-level algorithm optimization to high-level event-driven system design.

STL Algorithm Encapsulation: Standard library functions such as std::sort, std::find_if, and std::transform often require custom comparators or transformation logic. Using Lambdas can significantly reduce code lines and improve readability. For instance, passing [&](int a, int b){ return a > b; } directly during sorting achieves descending order arrangement.
Asynchronous Programming and Callbacks: In modern GUI frameworks (such as Qt) and server-side network libraries, event handling typically relies on callback functions. Lambda expressions allow developers to easily define anonymous handlers, avoiding the need to pass excessive parameters between class member functions or create complex intermediate structs.
Parallel Computing Optimization: When using parallel algorithms like std::parallel_for, if a Lambda needs to access shared data, it must use [&] reference capture; if isolated copies of data for each thread are needed to enhance safety and performance, copy capture [=] can be used.

When writing Lambdas involving complex logic (especially those containing loops or conditional statements), it is recommended to keep the code within three to four lines so that readers can immediately grasp the intent. Furthermore, one must pay close attention to lifetime issues introduced by reference capture: if an external variable depends on a temporary object on the stack that goes out of scope before the lambda executes, it leads to undefined behavior (UB). For such scenarios, copy capture or using smart pointers to manage resource lifetimes should be prioritized.

In summary, the combination of Lambda expressions and std::function forms the core foundation of functional programming style since C++11. Mastering their syntax details, capture mechanisms, and type conversion rules is an essential basic skill for every modern C++ developer.