C++Lambda表达式的使用

1
2
3
4
5
//C++11中的Lambda表达式用于定义并创建匿名的函数对象简化编程
[capture](parameters)mutable->return-type{statement}
//[捕获列表](参数列表)mutable ->返回值{函数体}
//当mutable修饰时，参数列表不可省略

1
2
3
4
5
6
7
8
9
10
11
12
捕获列表只能使用那些到定义Lambda为止时Lambda所在作用范围内可见的局部变量（包括Lambda所在类的this）。
[ ] 没有使用。
[=] 函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是值传递方式。
[&] 函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是引用传递方式。
[this] 函数体内可以使用Lambda所在类中的成员变量。
[a] 将a按值进行传递。按值进行传递时，函数体内不能修改传递进来的a的拷贝，
默认情况下函数是const的。要修改传递进来的a的拷贝，可以添加mutable修饰符,且参数列表不可省略。
[&a] 将a按引用进行传递。
[a,&b] 将a按值进行传递，b按引用进行传递。
[=,&a,&b] 除a和b按引用进行传递外，其他参数都按值进行传递。
[&,a,b] 除a和b按值进行传递外，其他参数都按引用进行传递。

1
2
3
当没有参数时，可以省略。
参数可以进行值传递和引用传递。

1
2
3
4
mutable声明，这部分可以省略。
按值传递函数对象参数时，加上mutable修饰符后，可以修改按值传递进来的拷贝。
这例只能修改拷贝，而不是值本身。

1
2
3
4
 ->返回值类型：
当返回值为void，或者函数体中只有一处return的地方时，
编译器可以自动推导出返回值类型，可以省略。

1
2
3
4
5
6
7
8
9
10
11
12
int main(){
int m = 10;
int n = [m]()mutable{m = m + 1;cout<<m<<endl;return m;}();
// m = 11
//如果没有mutable，因为m为值传递 m = m + 1报错
cout<<n<<endl;
// n = 11
cout<<m<<endl;
// m = 10
return 0;
}

1
2
3
4
5
6
7
8
int main(){
int m = 10;
[&](){m = m + 1;}();
cout<<m<<endl;
// m = 11
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
//Lambda表达式(匿名函数)
//[]捕获列表
()参数列表
->返回值类型
int c = [](int a,int b) -> int{return a+b;}(1,2);
cout<<c<<endl;	// 3 
//也可有以下写法：
auto f = [](int a,int b) -> int{return a+b;};
int c = f(1,2);
cout<<c<<endl;	// 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//Lambda表达式的嵌套
int c = [](int n){	//返回值类型由编译器自动推导
return [n](int x){
return n + x;
}(2);
}(1);
cout<<c<<endl;	// 3
//也可以有以下写法：
autu f = [](int n){
return [n](int x){
return n + x;
};
};
int c = f(1)(2);	//n = 1 x = 2
cout<<c<<endl;	// 3

1
2
3
4
//比较两值大小：
auto compareXY = [](int x,int y){if(x>y){return x;}else{return y;}};
std::cout<<compareXY(3,28)<<std::end