1. lambda 表达式1
需积分: 0 138 浏览量
2022-08-03
16:09:41
上传
评论
收藏 484KB PDF 举报
lambda
表
达
式
基
本
概
念
lambda
表
达
式
是
C++ 11
所
引
⼊
的
⾮
常
重
要
的
特
性
，
其
本
质
就
是
⼀个
匿
名
函
数
，
并
且
能
够
捕
获
⼀
定
范
围
内
的
变
量
基
本
格
式
[
捕
获
列
表
](
形
参
列
表
) ->
返
回
类
型
{ /*
函
数
体
*/ };
尾
置
返
回
类
型
[](const int& a, const int& b) -> bool {
return a < b;
}
特
性
和
普
通
函
数
不⼀
样
的
是
，
lambda
表
达
式
可
以
省
略
返
回
类
型
，
由
编
译
器
⾃
⾏
推
断
，
并
且不
需
要
使
⽤
decltype
[](const int& a, const int& b) {
return a < b;
};
由
编
译
器
⾃
⾏
推
断
，
返
回
类
型
为
bool
若
lambda
表
达
式
不
需
要
接
收
参
数
，
那
么
形
参
列
表
也
可
以
省
略
[] {
cout << "lambda" << endl;
};
形
参
列
表
和
返
回
类
型
可
以
都
被
省
略
捕
获
列
表
与
函
数
体
不
可
被
省
略
lambda
表
达
式
本
⾝
其
实
就
是
⼀个
匿
名
的
可
调
⽤
对
象
，
在
实
际
编
程
应应
尽
可
能
地
简
短
，
⼤
部
分
情
况
下
会
在
sort
、
for_each
等
函
数
中
使
⽤
捕
获
列
表
lambda
表
达
式
⽐
较
复
杂
和
容
易
出
错
的
地
⽅
就
在
于
捕
获
列
表
，
捕
获
列
表
可
以
看
作
是
将
外
部
作
⽤
域
中
的
变
量
“
搬
移
”
到
lambda
表
达
式
中
的
内
部
[]
表
⽰
不
捕
获
任
何
外
部
变
量
int main () {
int i = 1024;
auto f = [] {
cout << i << endl; // Wrong
};
}
lambda
表
达
式
有
⾃
⼰
的
作
⽤
域
，
虽
然
lambda
表
达
式
看
起
来
像
个
闭
包
，
但
是
不
能
直
接
获
取
外
部
作
⽤
域
的
变
量
[=]
表
⽰
按
值
⽅
式
捕
获
外
部
作
⽤
域
中
所
有
的
变
量
int main () {
int i = 1024;
auto f = [=] {
cout << i << endl; // Right
i = 2048; // Wrong
};
}
此
时
，
lambda
表
达
式
外
部
作
⽤
域
内
的
所
有
变
量
均
通过
按
值
传
递
的
⽅
式
传
递进
lambda
表
达
式
中
，
不
需
要
在
形
参
列
表
中
定
义
但
是
，
按
值
传
递
时
相
当
于
“
只
读
”
，
我
们
不
能
修
改
捕
获
的
变
量
按
值
捕
获
将
会
触
发
对
象
的
拷
⻉
动
作
，
对
于
⼤
对
象
⽽
⾔
，
需
要
慎
重
使
⽤
[&]
表
⽰
按
引
⽤
的
⽅
式
捕
获
外
部
作
⽤
域
中
的
所
有
变
量
int main () {
int i = 1024;
auto f = [&] {
cout << i << endl; // Right
i = 2048; // Right
};
}
当
我
们
使
⽤
按
引
⽤
的
⽅
式
捕
获
外
部
变
量
时
，
它
是
可
读
可
写
的
但
是
，
按
引
⽤
捕
获
外
部
变
量
在
lambda
表
达
式延
迟
调
⽤
时
必
须
保
证
这
些
变
量
仍
然
有
效
[
变
量
名
]
与
[&
变
量
名
]
有
时
候
我
们
并
不
需
要
外
部
作
⽤
域
中
的
全
部
变
量
，
那
么
我
们
就
可
以
使
⽤
这
种
⽅
式
进
⾏
按
需
捕
获
其
中
[
变
量
名
]
为
按
值
捕
获
该
变
量
，
[&
变
量
名
]
则
表
⽰
按
引
⽤
捕
获
该
变
量
[=, &
变
量
名
a, &
变
量
名
b, ...]
按
值
捕
获
外
部
所
有
的
变
量
，
但
是
按
引
⽤
的
⽅
式
捕
获
变
量
a
，
变
量
b
等
[&,
变
量
名
a,
变
量
名
b, ...]
按
引
⽤
捕
获
外
部
所
有
的
变
量
，
但
是
按
值
的
⽅
式
捕
获
变
量
a
，
变
量
b
等
[this]
使
得
lambda
表
达
式
内
部
可
访
问
成
员
变
量
⽤
于
类
中
，
其
作
⽤
就
是
捕
获
this
指
针
，
但
是
在
lambda
表
达
式
中
可
以
直
接
访
问
成
员
变
量
，
⽆
需
显
式
使
⽤
"this->"
另
外
，
如
果
我
们
使
⽤
了
[=]
或
者
是
[&]
，
this
指
针
也
会
被
捕
获
常
⻅
陷
阱
按
值
捕
获
时
，
对
象
的
复
制
发
⽣
在
定
义
lambda
表
达
式
那
⼀
刻
int i = 1024;
auto f = [=] { return i; };
i = 2048;
cout << f() << endl;
输
出
结
果
为
1024
，
并
⾮
2048
也
就
是
说
，
凡
是
按
值
捕
获
的
外
部
变
量
，
在
lambda
表
达
式
定
义
的
时
刻
，
所
有
的
外
部
变
量
的
值
就
已
经
被
复
制到
lambda
表
达
式
中了
按
引
⽤
捕
获
时
，
lambda
延
迟
调
⽤
的
时
刻
捕
获
对
象
已
失
效
vector<function<int(void)>> functions; //
定
义⼀个
function
容
器
void foo() {
int i = 1024;
functions.emplace_back([&]{return i;}); //
按
引
⽤
捕
获
变
量
i
}
int main() {
foo();
cout << functions[0]() << endl; //
调
⽤
lambda
表
达
式
return 0;
}
运
⾏
结
果
是
⼀个不
确
定
的
值
因
此
，
我
们
要
警
惕
按
引
⽤
捕
获
变
量
，
确
保
lambda
表
达
式
被
调
⽤
时
这
些
变
量
不
会
失
效
评论0