文章目录
Lambda 表达式
书写格式:
[capture_list](parameters) mutable -> return_type{statement}
[capture_list]:
- 捕捉列表,不能省略。
- 固定在 lambda 表达式开始的位置,编译器也是根据
[]
来判断接下来的代码是否为 lambda 函数。 - 捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。
(parameters):
- 参数列表。
- 与普通函数的参数列表一致,如果不需要参数传递,则可以连同
()
一起省略。
mutable:
- 一个修饰符,取消传值捕捉时值的默认 const 属性(lambda 函数默认是一个 const 类型的,里面的值不可修改)。
- 另:若使用了 mutable 修饰符,则
(参数列表)
是不可省略掉的,即使是参数为空。
return_type:
- 返回值类型。可以省略,编译器会自动推导。
{statement}:
- 函数体部分,{} 不能省略,但内容可以为空。
- 在该函数体内,除了可以使用其参数外,还可以使用所有捕获
到的变量。
如下是最简单的 lambda 对象,没啥用就是了…
[] {};
1. 不考虑捕捉列表
1.1 简单使用介绍
比如我们要实现一个两个数相加的函数,用 lambda 表达式就需要写成这样
auto add = [](int x, int y)->int {return x + y; };
cout << add(1, 2) << endl;
//cout << [](int x, int y)->int {return x + y; }(1, 2) << endl; // 这样写也能运行,但是我们不这样...
解析:
= 后面这一坨整体,代表的是一个 lambda 对象,拿这个对象去构造 add
后面就可以用 add 去等价调用函数了
可以看出,lambda 表达式实际上可以理解为 匿名函数,该函数无法直接调用,如果想要直接调用,可借助 auto 将其赋值给一个变量。
需要注意的是:
- 返回值可以忽略(编译器自动完成推导)
- 函数体语句多的话,可以按照如下格式写
auto add = [](int x, int y) // 返回值可以省略,编译器可以自动推导
{ // 函数体语句多的话,可以放下来写
return x + y;
};
cout << add2(1, 2) << endl;
1.2 简单使用举例
🌰实现商品各个内容的排序:
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
仿函数写法:
struct ComparePriceLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
// <
sort(v.begin(), v.end(), ComparePriceLess());
// >
sort(v.begin(), v.end(), ComparePriceGreater());
}
lambda 写法:
书写格式:[capture - list](parameters) mutable -> return-type{ statement}
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
// 价格升序
auto priceLess = [](const Goods& g1, const Goods& g2)->bool {return g1._price < g2._price; };
sort(v.begin(), v.end(), priceLess); // 相较于仿函数更好调试
// 价格降序
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
return g1._price > g2._price;
}); // 这个把断点放头上可能会一直出不来,调试的时候跳到了需要手动取消断点走下一个
// 改成比较别的类型也很方便
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
return g1._evaluate < g2._evaluate;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
return g1._evaluate > g2._evaluate;
});
return 0;
}
2. 捕捉列表 [ ] 和 mutable 关键字
📕注意事项(具体论证见下文):
-
父作用域指包含lambda函数的语句块。
-
语法上捕捉列表可由多个捕捉项组成,并以逗号分割。
-
捕捉列表不允许变量重复传递,否则就会导致编译错误。
eg:[=, a] = 已经以值传递方式捕捉了所有变量,捕捉 a 重复
-
在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量,捕捉任何非此作用域或者非局部变量都会导致编译报错。同时有,在块作用域以外的 lambda 函数捕捉列表必须为空。
-
lambda表达式之间不能相互赋值,即使看起来类型相同
若不使用 lambda 捕捉,实现一个 swap 接口如下:
int x = 0, y = 1;
auto swap1 = [](int& rx, int& ry)
{
int tmp = rx;
rx = ry;
ry = tmp;
};
swap1(x, y);
cout << x << " "<< y << endl;
而 捕捉列表 描述了:
- 上下文中哪些数据可以被 lambda 使用
- 以及使用的方式 传值 还是 传引用
2.1 使用方法
传值捕捉
-
[val]
是 传值捕捉 [x, y],相当于把 x 和 y “捕捉” 到 lambda 表达式中,直接就可以访问了。这时 lambda 是 const 函数,其中的 x 和 y 不能修改; -
加上关键字
mutable
就可以修改了,不过此时的 x 和 y 就是函数形参。 -
另外需要注意的是,有 mutable 时,参数列表的括号不能省略。建议平时也不要省略
并不能达到效果的错误使用:
// err,这是一个错误的写法
int x = 0, y = 1;
auto swap2 = [x, y]() mutable
{
int tmp = x;
x = y;
y = tmp;
};
swap2();
cout << x << " " << y << endl;
像如上,虽然对 x 和 y 进行了捕捉,也加上了 mutable 使其可以修改,但实际并达不到我们让全局变量 x 和 y 修改的效果。因为 lambda 中他们只是形参,一份临时拷贝的对象。
传引用捕捉
[&val]
是将外面的值传引用到 lambda 内部- 需要在 lambda 内部对某个变量修改时用传引用捕捉
真正修改了外面的参数:
// 这里的 &x 就是引用捕捉int& x(不是取地址
// 引用捕捉
int x = 0, y = 1;
auto swap2 = [&x, &y]()
{
int tmp = x;
x = y;
y = tmp;
};
swap2();
cout << x << " " << y << endl;
2.2 捕捉方法一览
混合捕捉
[var]
:表示 值传递方式 捕捉变量 var
[this]
:表示 值传递方式 捕捉当前的 this 指针
[&var]
:表示 引用传递捕捉 变量 var
auto func1 = [&x, y]()
{
//...
};
全部引用捕捉
[&]
:表示 引用传递捕捉 所有父作用域中的变量(包括 this)
auto func2 = [&]()
{
//...
};
全部传值捕捉
[=]
:表示值传递方式捕获所有父作用域中的变量(包括 this)
auto func3 = [=]()
{
//...
};
全部引用捕捉,x 传值捕捉
auto func4 = [&, x]()
{
//...
};
此外排列组合:
[=, &a, &b]
:以 引用传递 的方式捕捉变量 a 和 b,值传递方式 捕捉其他所有变量
[&,a, this]
:以 值传递方式 捕捉变量 a 和 this,引用方式 捕捉其他变量
2.3 使用举例
先来个讲解前提,创建线程:
- Linux 下创建线程:pthread_create(posix)
- C++98,linux 和 windows 下都可以支持的多线程程序:条件编译。
#ifdef _WIN32
CreateThread
#else
pthread_create
#endif
- C++11,linux 和 windows 下都可以支持的多线程程序:thread库。
🌰要求 m 个线程分别打印 1~n
线程的传统写法:
void Func1(int n, int num)
{
for (int i = 0; i < n; i++)
{
cout <<num<<":" << i << endl;
}
cout << endl;
}
int main()
{
int n1, n2;
cin >> n1 >> n2;
thread t1(Func1, n1, 1);
thread t2(Func1, n2, 2);
t1.join();
t2.join();
return 0;
}
lambda 写法:第一种,较为冗余,不便于添加线程
int main() // 这个版本蛮冗余
{
int n1, n2;
cin >> n1 >> n2;
thread t1([n1](int num)
{
for (int i = 0; i < n1; i++)
{
cout <<num<<":" << i << endl;
}
cout << endl;
}, 1);
thread t2([n2](int num)
{
for (int i = 0; i < n2; i++)
{
cout << num << ":" << i << endl;
}
cout << endl;
}, 2);
t1.join();
t2.join();
return 0;
}
lambda 写法:第二种,推荐
int main()
{
size_t m;
cin >> m;
vector<thread> vthds(m);
// 要求 m 个线程分别打印 1~n
for (size_t i = 0; i < m; i++)
{
size_t n;
cin >> n;
vthds[i] = thread([i, n, m]() { // 匿名的lambda对象,移动赋值给的vhds[i]
for (int j = 0; j < n; j++)
{
cout << i << ":" << j << endl;
}
cout << endl;
});
}
for (auto& t : vthds) // thread 不支持拷贝构造(delete了),这里要加引用才跑得动
{
t.join();
}
return 0;
}
3. lambda 的底层分析
先说结论,实际在底层编译器对于 lambda 表达式的处理方式,完全就是按照函数对象(仿函数)的方式处理的。
lambda 就是 仿函数
即:如果定义了一个 lambda 表达式,编译器会自动生成一个类,在该类中重载了 operator()。
- 参数列表 会变成 仿函数的参数
- 函数体 就是 仿函数主体
- lambda 对象的类型 就是 仿函数的类型(见后文)
- 如下这个仿函数类是一个没有给成员变量的空类,所以大小是 1 个字节 反汇编可以查到
int x = 0, y = 1;
int m = 0, n = 1;
auto swap1 = [](int& rx, int& ry)
{
int tmp = rx;
rx = ry;
ry = tmp;
};
cout << sizeof(swap1) << endl; // 输出 1
有如下一个模拟计算理财收益的类:
class Rate
{
public:
Rate(double rate) : _rate(rate) {} // 传入利率
double operator()(double money, int year) // 参数:本金和年限,返回收益
{
return money * _rate * year; // 模拟计算
}
private:
double _rate;
};
- 以下代码,函数对象的汇编过程:call 仿函数的构造函数,再 call operator()
// 函数对象
int main()
{
double rate = 0.49;
Rate r1(rate);
r1(10000, 2);
cout << sizeof(r1) << endl; // 8
return 0;
}
-
以下代码,lambda 汇编过程:call
lambda_uuid
类的构造函数,再call <lambda_uuid>::operator() -
uuid 是一个电脑生成的唯一随机值,作为 lambda 类的后缀,刚刚好唯一标识
lambda 类的大小
既然说 lambda 会被编译成类,那么他的大小也就跟类的大小的计算如出一辙,不过还是有需要注意的地方,🌰请看以下简单示意:
- 使用 [=],并在 lambda 中使用的值才会被类初始化,初始化顺序和使用顺序有关,大小计算参考结构体的 内存对齐规则。
- 使用 [&],并在 lambda 中使用的值,引用会被类定义成指针,其余规则同上。
lambda 类的类型名 / 唯一标识
- 之前提及的 lambda_uuid,才是 lambda 表达式底层的类型名称,编译器会给他们唯一标识的名称
下面代码,f1 和 f2 即使看着一样,如上阐述,实则底层的类型名称都不同,不能互相赋值:
auto f1 = [] {cout << "hello world" << endl; };
auto f2 = [] {cout << "hello world" << endl; };
//f1 = f2; // err...
🥰如果本文对你有些帮助,欢迎👉 点赞 收藏 关注,你的支持是对作者大大莫大的鼓励!!(✿◡‿◡) 若有差错恳请留言指正~~