【C++11】lambda和包装器
1.新的类功能
1.1默认的移动构造和移动赋值
原来C++类中，有6个默认成员函数：构造函数/析构函数/拷⻉构造函数/拷⻉赋值重载/取地址重 载/const 取地址重载，最后重要的是前4个，后两个⽤处不⼤，默认成员函数就是我们不写编译器 会⽣成⼀个默认的。C++11 新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。
如果你没有⾃⼰实现移动构造函数，且没有实现析构函数 、拷⻉构造、拷⻉赋值重载中的任意⼀ 个。那么编译器会⾃动⽣成⼀个默认移动构造。默认⽣成的移动构造函数，对于内置类型成员会执 ⾏逐成员按字节拷⻉，⾃定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调⽤ 移动构造，没有实现就调⽤拷⻉构造。
如果你没有⾃⼰实现移动赋值重载函数，且没有实现析构函数 、拷⻉构造、拷⻉赋值重载中的任意 ⼀个，那么编译器会⾃动⽣成⼀个默认移动赋值。默认⽣成的移动构造函数，对于内置类型成员会 执⾏逐成员按字节拷⻉，⾃定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调⽤移动赋值，没有实现就调⽤拷⻉赋值。(默认移动赋值跟上⾯移动构造完全类似)
如果你提供了移动构造或者移动赋值，编译器不会⾃动提供拷⻉构造和拷⻉赋值。
1.2defult和delete
C++11可以让你更好的控制要使⽤的默认函数。假设你要使⽤某个默认的函数，但是因为⼀些原因 这个函数没有默认⽣成。⽐如：我们提供了拷⻉构造，就不会⽣成移动构造了，那么我们可以使⽤ default关键字显⽰指定移动构造⽣成。
如果能想要限制某些默认函数的⽣成，在C++98中，是该函数设置成private，并且只声明补丁已， 这样只要其他⼈想要调⽤就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指⽰编译器不⽣成对应函数的默认版本，称=delete修饰的函数为删除函数。
2.STL中⼀些变化
下图1圈起来的就是STL中的新容器，但是实际最有⽤的是unordered_map和unordered_set。这 两个我们前⾯已经进⾏了⾮常详细的讲解，其他的⼤家了解⼀下即可。
STL中容器的新接⼝也不少，最重要的就是右值引⽤和移动语义相关的push/insert/emplace系列接⼝和移动构造和移动赋值，还有initializer_list版本的构造等，这些前⾯都讲过了，还有⼀些⽆关痛痒的如cbegin/cend等需要时查查⽂档即可。
容器的范围for遍历，这个在容器部分也讲过了。
3.lambda
3.1lambda表达式语法
lambda 表达式本质是⼀个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。 lambda 表达式语法使⽤层⽽⾔没有类型，所以我们⼀般是⽤auto或者模板参数定义的对象去接 收 lambda 对象。
lambda表达式的格式： [capture-list] (parameters)-> return type { function boby }
[capture-list] : 捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据[]来 判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下⽂中的变量供 lambda 函数使 ⽤，捕捉列表可以传值和传引⽤捕捉，具体细节3.2中我们再细讲。捕捉列表为空也不能省略。
(parameters) ：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连 同()⼀起省略
->return type ：返回值类型，⽤追踪返回类型形式声明函数的返回值类型，没有返回值时此 部分可省略。⼀般返回值类型明确情况下，也可省略，由编译器对返回类型进⾏推导。
{function boby} ：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以 使⽤其参数外，还可以使⽤所有捕获到的变量，函数体为空也不能省略。
int main()
{
// ⼀个简单的lambda表达式
auto add1 = [](int x, int y)->int {return x + y; };
cout << add1(1, 2) << endl;
// 1、捕捉为空也不能省略
// 2、参数为空可以省略
// 3、返回值可以省略，可以通过返回对象⾃动推导
// 4、函数体不能省略
auto func1 = []
{
cout << "hello xc" << endl;
return 0;
};
func1();
int a = 0, b = 1;
auto swap1 = [](int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
};
swap1(a, b);
cout << a << ":" << b << endl;
return 0;
}运行结果：
3.2捕捉列表
lambda 表达式中默认只能⽤ lambda 函数体和参数中的变量，如果想⽤外层作⽤域中的变量就 需要进⾏捕捉
第⼀种捕捉⽅式是在捕捉列表中显⽰的传值捕捉和传引⽤捕捉，捕捉的多个变量⽤逗号分割。[x， y， &z] 表⽰x和y值捕捉，z引⽤捕捉。
第⼆种捕捉⽅式是在捕捉列表中隐式捕捉，我们在捕捉列表写⼀个=表⽰隐式值捕捉，在捕捉列表 写⼀个&表⽰隐式引⽤捕捉，这样我们 lambda 表达式中⽤了那些变量，编译器就会⾃动捕捉那些 变量。
第三种捕捉⽅式是在捕捉列表中混合使⽤隐式捕捉和显⽰捕捉。[=, &x]表⽰其他变量隐式值捕捉， x引⽤捕捉；[&, x, y]表⽰其他变量引⽤捕捉，x和y值捕捉。当使⽤混合捕捉时，第⼀个元素必须是 &或=，并且&混合捕捉时，后⾯的捕捉变量必须是值捕捉，同理=混合捕捉时，后⾯的捕捉变量必 须是引⽤捕捉。
lambda 表达式如果在函数局部域中，他可以捕捉 lambda 位置之前定义的变量，不能捕捉静态 局部变量和全局变量，静态局部变量和全局变量也不需要捕捉， lambda 表达式中可以直接使⽤。这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。
默认情况下， lambda 捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改， mutable加在参数列表的后⾯可以取消其常量性，也就说使⽤该修饰符后，传值捕捉的对象就可以 修改了，但是修改还是形参对象，不会影响实参。使⽤该修饰符后，参数列表不可省略(即使参数为 空)。
相关代码如下：
int y = 0;
// 捕捉列表必须为空，因为全局变量不⽤捕捉就可以⽤，没有可被捕捉的变量
auto func2 = []()
{
y++;
};
int main()
{
// 只能用当前lambda局部域和捕捉的对象和全局对象
int a = 0, b = 1, c = 2, d = 3;
auto func1 = [a, &b](int x)mutable
{
// 值捕捉的变量不能修改，引用捕捉的变量可以修改
a++;
b++;
int ret = a + b + x + y;
return ret;
};
//cout << func1(1) << endl;
//func2();
// 隐式值捕捉
// 用了哪些变量就捕捉哪些变量
auto func2 = [=]
{
int ret = a + b + c;
return ret;
};
//cout << func2() << endl;
// 隐式引用捕捉
// 用了哪些变量就捕捉哪些变量
auto func3 = [&]
{
a++;
c++;
d++;
};
//func3();
//cout << a << " " << b << " " << c << " " << d << endl;
// 混合捕捉1(a和b值捕捉)
auto func4 = [&,a,b]
{
//a++;
//b++;
c++;
d++;
return a + b + c + d;
};
//func4();
//cout << a << " " << b << " " << c << " " << d << endl;
// 混合捕捉2(a和b引用捕捉)
auto func5 = [=, &a, &b]
{
a++;
b++;
//c++;
//d++;
return a + b + c + d;
};
func5();
cout << a << " " << b << " " << c << " " << d << endl;
// 传值捕捉本质是⼀种拷⻉,并且被const修饰了
// mutable相当于去掉const属性，可以修改了
// 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉
auto func7 = [=]()mutable
{
a++;
b++;
c++;
d++;
return a + b + c + d;
};
//cout << func7() << endl;
//cout << a << " " << b << " " << c << " " << d << endl;
return 0;
}3.3lambda的应用
在学习 lambda 表达式之前，我们的使⽤的可调⽤对象只有函数指针和仿函数对象，函数指针的 类型定义起来⽐较⿇烦，仿函数要定义⼀个类，相对会⽐较⿇烦。使⽤ lambda 去定义可调⽤对 象，既简单⼜⽅便。
lambda 在很多其他地⽅⽤起来也很好⽤。⽐如线程中定义线程的执⾏函数逻辑，智能指针中定 制删除器等， lambda 的应⽤还是很⼴泛的，以后我们会不断接触到
#include<algorithm>
struct Goods
{
string _name; //名字
double _price; //价格
int _evaluate; //评价
//...
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
struct Compare1
{
bool operator()(const Goods& g1, const Goods& gr)
{
return g1._price < gr._price;
}
};
struct Compare2
{
bool operator()(const Goods& g1, const Goods& gr)
{
return g1._price > gr._price;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3}, { "菠萝", 1.5, 4 } };
// 类似这样的场景，我们实现仿函数对象或者函数指针支持商品中
// 不同项的比较，相对还是比较麻烦的，那么这里lambda就很好用了
// 价格升序
//sort(v.begin(), v.end(), Compare1());
// 价格降序
//sort(v.begin(), v.end(), Compare2());
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price > g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate < g2._evaluate; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate > g2._evaluate; });
return 0;
}
3.4 lambda的原理
lambda 的原理和范围for很像，编译后从汇编指令层的⻆度看，压根就没有 lambda 和范围for 这样的东西。范围for底层是迭代器，⽽lambda底层是仿函数对象，也就说我们写了⼀个 lambda 以后，编译器会⽣成⼀个对应的仿函数的类。
仿函数的类名是编译按⼀定规则⽣成的，保证不同的 lambda ⽣成的类名不同，lambda参数/返 回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是⽣成 的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕 捉，编译器要看使⽤哪些就传那些对象。
上⾯的原理，我们可以透过汇编层了解⼀下，下⾯第⼆段汇编层代码印证了上⾯的原理。
class Rate
{
public:
Rate(double rate)
: _rate(rate)
{}
double operator()(double money, int year)
{
return money * _rate * year;
}
private:
double _rate;
};
int main()
{
double rate = 0.49;
//lambda
auto r2 = [rate](double money, int year) {
return money * rate * year;
};
// 捕捉列表的rate，可以看到作为lambda_1类构造函数的参数传递了，这样要拿去初始化成员变量
//函数对象
Rate r1(rate);
r1(10000, 2);
r2(10000, 2);
auto func1 = [] {
cout << "hello world" << endl;
};
func1();
return 0;
}
4. 包装器
4.1 function
template <class T>
class function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;std::function 是⼀个类模板，也是⼀个包装器。 std::function 的实例对象可以包装存 储其他的可以调⽤对象，包括函数指针、仿函数、 lambda 、 bind 表达式等，存储的可调⽤对 象被称为 std::function 的⽬标。若 std::function 不含⽬标，则称它为空。调⽤空 std::function 的⽬标导致抛出 std::bad_function_call异常。
以上是 function 的原型，他被定义头⽂件中。std::function - cppreference.com 是function的官⽅⽂件链接。
函数指针、仿函数、 lambda 等可调⽤对象的类型各不相同， std::function 的优势就是统 ⼀类型，对他们都可以进⾏包装，这样在很多地⽅就⽅便声明可调⽤对象的类型，下⾯的第⼆个代 码样例展⽰了 std::function 作为map的参数，实现字符串和可调⽤对象的映射表功能。
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
class Plus
{
public:
Plus(int n = 10)
:_n(n)
{}
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return (a + b) * _n;
}
private:
int _n;
};
int main()
{
// 包装各种可调用对象
function<int(int, int)>f1 = f;
function<int(int, int)>f2 = Functor();
function<int(int, int)>f3 = [](int a, int b) {return a + b; };
cout << f1(1, 1) << endl;
cout << f2(1, 1) << endl;
cout << f3(1, 1) << endl;
// 包装静态成员函数
// 成员函数要指定类域并且前面加&才能获取地址
//静态前面可加可不加(&),建议加上
function<int(int, int)> f4 = &Plus::plusi;
cout << f4(1, 1) << endl;
function<double(Plus*, double, double)> f5 = &Plus::plusd;
Plus pl;
cout << f5(&pl, 1.111, 1.1) << endl;
function<double(Plus, double, double)> f6 = &Plus::plusd;
cout << f6(pl, 1.1, 1.1) << endl;
cout << f6(Plus(), 1.1, 1.1) << endl;//匿名对象
function<double(Plus&&, double, double)> f7 = &Plus::plusd;
cout << f7(move(pl), 1.1, 1.1) << endl;
cout << f7(Plus(), 1.1, 1.1) << endl;
return 0;
}
传统⽅式的实现
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
for (auto& str : tokens)
{
if (str == "+" || str == "-" || str == "*" || str == "/")
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
switch (str[0])
{
case '+':
st.push(left + right);
break;
case '-':
st.push(left - right);
break;
case '*':
st.push(left * right);
break;
case '/':
st.push(left / right);
break;
}
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};使⽤map映射string和function的⽅式实现 ，这种⽅式的最⼤优势之⼀是⽅便扩展，假设还有其他运算，我们增加map中的映射即可
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
// function作为map的映射可调⽤对象的类型
map<string ,function<int(int,int)>>opFuncMap =
{
{"+",[](int x,int y){return x + y;}},
{"-",[](int x,int y){return x - y;}},
{"*",[](int x,int y){return x * y;}},
{"/",[](int x,int y){return x / y;}}
};
for (auto& str : tokens)
{
if(opFuncMap.count(str))// 操作符
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
int ret = opFuncMap[str](left,right);
st.push(ret);
}
else
{
st.push(stoi(str));
}
}
return st.top();
}
};4.2 bind
simple(1)
template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
with return type(2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn && fn, Args&&... args);bind 是⼀个函数模板，它也是⼀个可调⽤对象的包装器，可以把他看做⼀个函数适配器，对接收 的fn可调⽤对象进⾏处理后返回⼀个可调⽤对象。 bind 可以⽤来调整参数个数和参数顺序。 bind 也在这个头⽂件中。
调⽤bind的⼀般形式： auto newCallable = bind(callable,arg_list); 其中 newCallable本⾝是⼀个可调⽤对象，arg_list是⼀个逗号分隔的参数列表，对应给定的callable的 参数。当我们调⽤newCallable时，newCallable会调⽤callable，并传给它arg_list中的参数。
arg_list中的参数可能包含形如_n的名字，其中n是⼀个整数，这些参数是占位符，表⽰ newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表⽰⽣成的可调⽤对象 中参数的位置：_1为newCallable的第⼀个参数，_2为第⼆个参数，以此类推。_1/_2/_3....这些占 位符放到placeholders的⼀个命名空间中。
相关代码如下：
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int Sub(int a, int b)
{
return(a - b) * 10;
}
int SubX(int a, int b, int c)
{
return (a - b - c) * 10;
}
class Plus
{
public:
Plus(int n = 10)
:_n(n)
{}
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return (a + b) * _n;
}
private:
int _n;
};
int main()
{
bind 本质返回的⼀个仿函数对象
调整参数顺序（不常⽤）
_1代表第⼀个实参
_2代表第⼆个实参
//auto sub1 = bind(Sub, _1, _2);
//cout << sub1(10, 5) << endl;
//auto sub2 = bind(Sub, _2, _1);
//cout << sub2(10, 5) << endl;
调整参数个数 （常用）
//auto sub3 = bind(Sub, 100, _1);
//cout << sub3(5) << endl;
//auto sub4 = bind(Sub, _1, 100);
//cout << sub4(5) << endl;
分别绑死第123个参数
//auto sub5 = bind(SubX, 100, _1, _2);
//cout << sub5(5, 1) << endl;
//auto sub6 = bind(SubX, _1, 100, _2);
//cout << sub6(5, 1) << endl;
//auto sub7 = bind(SubX, _1, _2, 100);
//cout << sub7(5, 1) << endl;
// 成员函数对象进行绑死，就不需要每次都传递了
//function<double(Plus&&, double, double)> f8 = &Plus::plusd;
//Plus pd;
//cout << f8(move(pd), 1.1, 1.1) << endl;
//cout << f8(Plus(), 1.1, 1.1) << endl;
//function<double(double, double)> f9 = bind(&Plus::plusd, Plus(), _1, _2);
//cout << f9(1.1, 1.1) << endl;
// 计算复利的lambda
// 复利前一年的利息变成第二年本金
// (10000*0.02 + 10000)*0.02 + 10000*0.02 + 10000
// 利率 本金 年限
auto func1 = [](double rate, double money, int year)->double
{
double ret = money;
for (int i = 0; i < year; i++)
{
ret += ret * rate;
}
return ret - money;//减去本金
};
cout << func1(0.05, 10000000, 30) << endl;
// 绑死一些参数，实现出支持不同年华利率，不同金额和不同年份计算出复利的结算利息
function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);
function<double(double)> func10_1_5 = bind(func1, 0.015, _1, 10);
function<double(double)> func3_2_5 = bind(func1, 0.025, _1, 3);
function<double(double)> func5_2_5 = bind(func1, 0.025, _1, 5);
function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);
cout << func3_1_5(1000000) << endl;
cout << func5_1_5(1000000) << endl;
cout << func10_1_5(1000000) << endl;
cout << func3_2_5(1000000) << endl;
cout << func5_2_5(1000000) << endl;
cout << func10_2_5(1000000) << endl;
return 0;
}本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2025-02-10，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录
腾讯云开发者
