【C++11】Lambda 表达式：基本使用 和 底层原理
文章目录
- Lambda 表达式
-
- 1. 不考虑捕捉列表
-
- 1.1 简单使用介绍
- 1.2 简单使用举例
- 2. 捕捉列表 [ ] 和 mutable 关键字
-
- 2.1 使用方法
- 2.2 不同的捕捉方法
- 2.3 使用举例
- 3. lambda 的底层分析
Lambda 表达式
书写格式：
[capture_list](parameters) mutable -> return_type{statement}
- [capture_list]：捕捉列表，不能省略
- (parameters)：参数列表
- mutable：一个修饰符，取消传值捕捉时值的 const 属性
另：若使用了 mutable 修饰符，则 (参数列表) 是不可省略掉的，即使是参数为空 - return_type：返回值类型。可以省略，编译器会自动推导。
- {statement}：函数体部分，不能省略
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 去等价调用函数了
需要注意的是：
- 返回值可以忽略（编译器自动完成推导）
- 函数体语句多的话，可以按照如下格式写
auto add = [](int x, int y) // 返回值可以省略，编译器可以自动推导
{ // 函数体语句多的话，可以放下来写
return x + y;
};
cout << add2(1, 2) << endl;
如下是最简单的 lambda 对象。
[] {};
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 传值捕捉，实现一个 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;
2.1 使用方法
-
使用 传值捕捉 [x, y]，相当于把 x 和 y “捕捉” 到 lambda 表达式中，直接就可以访问了。这时 lambda 中的 x 和 y 不能修改，类似 const；
-
加上关键字
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 中他们只是形参，一份临时拷贝的对象。
正确使用 传值捕捉：
// 这里的 &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 不同的捕捉方法
混合捕捉
auto func1 = [&x, y]()
{
//...
};
全部引用捕捉
auto func2 = [&]()
{
//...
};
全部传值捕捉
auto func3 = [=]()
{
//...
};
全部引用捕捉，x 传值捕捉
auto func4 = [&, x]()
{
//...
};
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 对象的类型 就是 仿函数的类型（见后文）
- 如下这个仿函数类是一个没有给成员变量的空类，所以大小是 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
::operator() -
uuid 是一个电脑生成的唯一随机值，作为 lambda 类的后缀，刚刚好唯一标识
查看 r2 的大小，r2 里面没使用 lambda 涉及参数之外的 变量 n（如果用了的话根据内存对齐规则，r2 的大小是 16），也就是说：
- [=] 实际使用的值，才会在 lambda 类中作为成员变量初始化，所以这里的 8 是 double _rate 的大小
int main()
{
double rate = 0.49;
int n = 0; // 测试 [=] 全部传值捕捉
auto r2 = [=](double money, int year)->double {return money * rate * year; };
r2(10000, 2);
cout << sizeof(r2) << endl; // 8
return 0;
}
// 所以：lambda 和范围 for 一样，底层是用别的实现的，被封装了一趟而已
- 之前提及的 lambda_uuid，才是 lambda 表达式底层的类型名称，编译器会给他们唯一标识的名称
下面代码，f1 和 f2 即使看着一样，如上阐述，实则类型名称都不同，不能互相赋值：
auto f1 = [] {cout << "hello world" << endl; };
auto f2 = [] {cout << "hello world" << endl; };
//f1 = f2; // err...
如果本文对你有些帮助，请给个赞或收藏，你的支持是对作者大大莫大的鼓励！！(✿◡‿◡) 欢迎评论留言~~