c++ lambda 表达式

1. 简介

lambda（匿名函数）是C++11引入的一种函数对象，它允许我们在需要函数的地方创建一个临时的、匿名的函数。lambda表达式表示一个可以执行的代码单元，可以理解为一个未命名的内联函数。Lambda函数可以用于简化代码、提高可读性，并且常与算法、STL容器、多线程等一起使用。

2. Lambda表达式的语法形式

[capture list] (parameter list) -> return type { function body }
1

capture list（捕获列表）：可以捕获一定范围内的变量，可以为空。用于指定在lambda函数中使用的外部变量。
parameter list（参数列表）：函数参数列表，可以为空。
return type（返回类型）：指定lambda表达式返回值类型，可以省略，让编译器自动推导返回类型
function body（函数体）：定义了lambda表达式执行的代码块。

2.1 简化

原函数：

int add(int a , int b){
    return a  + b;
}
void printword(){
    std::cout << "aa" << std::endl;
}
1
2
3
4
5
6

lambda 函数：

//1. 最完整的语法：
//[]()->返回值{};
//捕获列表 函数的参数->函数返回值{函数体};
[](int a , int b)->int{return a + b;} ;
//2. 简化 ：返回值可以不用写，编译器可以推断返回值的类型
[](int a , int b){return a + b;};
//3. 简化，如果函数的参数没有，那么()也可以不用那些了。
[]{;};
例如：
    []{
        std::cout << "hello world" << std::endl;
    };

1
2
3
4
5
6
7
8
9
10
11
12
13

3. 调用Lambda函数

[]{std::cout << "hello world" << std::endl;};
1

仅仅是定义了一个函数，这个函数不会被执行
要想调用这个函数，需要使用函数名字()来调用，或者使用函数指针来接收它然后调用。

3.1 函数名字() 调用Lambda函数

1. 无参数，无返回值
[]{std::cout << "hello world" << std::endl;}();
2. 有参数，有返回值
[](int a , int b){return a + b;}(10,20);
1
2
3
4

3.2 函数指针调用Lambda函数

1. 无参数，无返回值
void(*f)() = []{
    std::cout << "hello world" << std::endl;
};
f();
2. 有参数，有返回值
int(*fadd)(int,int)  =[](int a , int b){
       return a  + b;
};
cout <<  fadd(10,20) <<endl;
1
2
3
4
5
6
7
8
9
10

3.3 auto 调用Lambda函数

```cpp
1. 无参数，无返回值
auto f = []{
    std::cout << "hello world" << std::endl;
};
f();
2. 有参数，有返回值
auto fadd = [](int a , int b){
       return a  + b;
};
cout <<  fadd(10,20) <<endl;
1
2
3
4
5
6
7
8
9
10
11

4. 捕获列表的使用

lambda表达式需要在函数体中定义，这时如果想访问所处函数中的某个成员（局部变量），那么就需要使用捕获列表了。捕获列表的写法通常有以下几种形式：

代码：

#include

using namespace std;

int main(){
    
    int a = 20 ;
    int b = 30;

    //值传递方式捕获 a 和 b，在lambda 函数体内无法修改a和b的值
    auto f1 = [a,b]{return a + b;}; 
    cout << f1()  << endl; 


    //引用方式捕获 a 和 b  , 可以在内部修改a 和 b的值
    auto f2 = [&a,&b]{ 
        a = 40; //这里修改会导致外部的a 也跟着修改。
        return a + b;
    };
    
    cout << f2()  << endl; //这里打印35
    cout << "a= "<< a << endl; //再打印一次，a 变成30了
    
    return 0 ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4. 特点

匿名性：Lambda函数是匿名的，没有函数名。它的定义和使用都是在需要的地方，无需提前声明。
闭包（Closure）：Lambda函数可以捕获外部作用域的变量，包括局部变量、函数参数、全局变量等，并在函数体内使用。捕获方式可通过捕获列表进行指定。捕获的变量可以在函数体内进行读取和修改。
自动推导：Lambda函数的参数类型和返回类型可以通过编译器自动推导，可以省略。如果省略返回类型，则根据函数体中的返回语句自动推导返回类型。
函数对象：Lambda函数实际上是一个函数对象，可以像普通函数一样被调用。可以将Lambda函数作为参数传递给其他函数，也可以存储在容器中。
代码：

#include 
#include 
#include 

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

    // Lambda函数作为参数传递给std::for_each算法
    std::for_each(numbers.begin(), numbers.end(), [](int num) {
        std::cout << num << " ";
    });

    // Lambda函数捕获外部变量，并进行计算
    int factor = 2;
    std::transform(numbers.begin(), numbers.end(), numbers.begin(), [factor](int num) {
        return num * factor;
    });

    // Lambda函数作为谓词进行排序
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a > b;
    });

    // 输出结果
    for (int num : numbers) {
        std::cout << num << " ";
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在 std::for_each 算法中，使用Lambda函数作为参数，遍历 numbers 容器并输出每个元素。
在 std::transform 算法中，使用Lambda函数对 numbers 容器中的每个元素进行乘以 factor 的操作。
在 std::sort 算法中，使用Lambda函数作为谓词，根据元素的大小进行降序排序。

5. 使用场景

1. 标准算法：作为标准算法的参数，用于定制算法的行为。例如，使用Lambda函数作为谓词对容器进行筛选、排序等操作

#include 
#include 
#include 

int main() {
    std::vector<int> numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 使用Lambda函数作为谓词，筛选出偶数
    auto isEven = [](int num) {
        return num % 2 == 0;
    };
    std::vector<int> evenNumbers;
    std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(evenNumbers), isEven);

    // 输出结果
    for (int num : evenNumbers) {
        std::cout << num << " ";
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2. 回调函数：作为回调函数传递给其他函数，用于处理特定事件或条件。

#include 
#include 

// 模拟事件处理器
void processEvent(int data, std::function<void(int)> callback) {
    // 处理事件
    // ...

    // 调用回调函数
    callback(data);
}

int main() {
    int eventData = 0;

    // 使用Lambda函数作为回调函数
    processEvent(eventData, [](int data) {
        std::cout << "Event processed with data: " << data << std::endl;
    });

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

或者：

#include 
#include 

void performOperation(int a, int b, std::function<void(int)> callback) {
    int result = a + b;
    callback(result);
}

int main() {
    int x = 5, y = 3;

    performOperation(x, y, [](int result) {
        std::cout << "The result is: " << result << std::endl;
    });

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. 多线程编程：作为线程的执行体，方便地捕获外部变量。

#include 
#include 

int main() {
    int value = 42;

    // 使用Lambda函数作为线程的执行体
    std::thread t([&value]() {
        // 在子线程中使用外部变量
        std::cout << "Value in thread: " << value << std::endl;
    });

    // 等待子线程结束
    t.join();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4. 函数对象的临时定义：在需要临时定义函数对象的场景，避免为简单的操作额外定义函数。

#include 
#include 
#include 

int main() {
    std::vector<int> numbers = {3, 1, 4, 1, 5};

    // 使用Lambda函数作为函数对象
    std::for_each(numbers.begin(), numbers.end(), [](int num) {
        std::cout << num << " ";
    });

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14