C++11的特性与新语法（下）

目录

4>可变参数模板

a.基本语法及原理

b.包扩展

c.empalce系列接口

5>新的类功能

a.默认的移动构造和移动赋值

b.成员变量声明时给缺省值

c.defult和delete

d.final和override

6>STL中的变化

7>lambda

a.lambda表达式语法

b.捕捉列表

c.lambda的应用

d.lambda的原理

8.包装器

a.function

b.bind

---

4>可变参数模板

a.基本语法及原理

• C++11⽀持可变参数模板，也就是说⽀持可变数量参数的函数模板和类模板，可变数⽬的参数被称为参数包，存在两种参数包：模板参数包，表⽰零或多个模板参数；函数参数包：表⽰零或多个函数参数

• template <class ...Args> void Func(Args... args) {}

• template <class ...Args> void Func(Args&... args) {}

• template <class ...Args> void Func(Args&&... args) {}

• 我们⽤省略号来指出⼀个模板参数或函数参数的表⽰⼀个包，在模板参数列表中，class...或typename...指出接下来的参数表⽰零或多个类型列表；在函数参数列表中，类型名后⾯跟...指出接下来表⽰零或多个形参对象列表；函数参数包可以⽤左值引⽤或右值引⽤表⽰，跟前⾯普通模板⼀样，每个参数实例化时遵循引⽤折叠规则

• 可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数

• 这⾥我们可以使⽤sizeof...运算符去计算参数包中参数的个数

template <class ...Args>
void Print(Args&&... args)
{cout << sizeof...(args) << endl;
} int main()
{double x = 2.2;Print(); // 包⾥有0个参数Print(1); // 包⾥有1个参数Print(1, string("xxxxx")); // 包⾥有2个参数Print(1.1, string("xxxxx"), x); // 包⾥有3个参数return 0;
}// 原理1: 编译本质这里会结合引用折叠规则实例化出以下四个函数
void Print();
void Print(int&& arg1);
void Print(int&& arg1, string&& arg2);
void Print(double&& arg1, string&& arg2, double& arg3);// 原理2: 更本质去看没有可变参数模板，我们实现出这样的多个函数模板才能支持
// 这里的功能，有了可变参数模板，我们进一步被解放，它是类型泛化基础
// 上叠加数量变化，让我们泛型编程更灵活
void Print();template <class T1>
void Print(T1&& arg1);template <class T1, class T2>
void Print(T1&& arg1, T2&& arg2);template <class T1, class T2, class T3>
void Print(T1&& arg1, T2&& arg2, T3&& arg3);

b.包扩展

• 对于⼀个参数包，我们除了能计算它的参数个数，我们能做的唯⼀的事情就是扩展它，当扩展⼀个包时，我们还要提供⽤于每个扩展元素的模式，扩展⼀个包就是将它分解为构成的元素，对每个元素应⽤模式，获得扩展后的列表。我们通过在模式的右边放⼀个省略号(...)来触发扩展操作。底层的实现细节如下图所⽰

• C++还⽀持更复杂的包扩展，直接将参数包依次展开依次作为实参给⼀个函数去处理

// 可变模板参数
// 参数类型可变  参数个数可变
// 打印参数包内容//template <class ...Args>
//void Print(Args... args)
//{
// // 可变参数模板编译时解析
// // 下面是运行获取和解析，所以不支持这样用
// cout << sizeof...(args) << endl;
// for (size_t i = 0; i < sizeof...(args); i++)
// {
//		cout << args[i] << " ";
// }
// cout << endl;
//}void ShowList()
{// 编译器时递归的终止条件，参数包是0个时，直接匹配这个函数cout << endl;
} template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包// 调用ShowList，参数包的第一个传给x，剩下N-1传给第二个参数包ShowList(args...);
} // 编译时递归推导解析参数
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
} int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}

template <class T>
const T& GetArg(const T& x)
{cout << x << " ";return x;
} template <class ...Args>
void Arguments(Args... args)
{}template <class ...Args>
void Print(Args... args)
{// 注意GetArg必须返回或者到的对象，这样才能组成参数包给ArgumentsArguments(GetArg(args)...);
} 
// 本质可以理解为编译器编译时，包的扩展模式
// 将上面的函数模板扩展实例化为下面的函数
// 是不是很抽象，C++11以后，只能说委员会的大佬设计语法思维跳跃得太厉害
//void Print(int x, string y, double z)
//{
// Arguments(GetArg(x), GetArg(y), GetArg(z));
//}int main()
{Print(1, string("xxxxx"), 2.2);return 0;
}

c.empalce系列接口

• template <class... Args> void emplace_back (Args&&... args);

• template <class... Args> iterator emplace (const_iterator position, Args&&... args);

• C++11以后STL容器新增了empalce系列的接⼝，empalce系列的接⼝均为模板可变参数，功能上兼容push和insert系列，但是empalce还⽀持新玩法，假设容器为container<T>，empalce还⽀持直接插⼊构造T对象的参数，这样有些场景会更⾼效⼀些，可以直接在容器空间上构造T对象。

• emplace_back总体⽽⾔是更⾼效，推荐以后使⽤empalce系列替代insert和push系列

• 第⼆个程序中我们模拟实现了list的empalce和emplace_back接⼝，这⾥把参数包不段往下传递，最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前⾯说的empalce⽀持直接插⼊构造T对象的参数，这样有些场景会更⾼效⼀些，可以直接在容器空间上构造T对象

• 传递参数包过程中，如果是Args&&... args的参数包，要⽤完美转发参数包，⽅式如下std::forward<Args>(args)... ，否则编译时包扩展后右值引⽤变量表达式就变成了左值

// emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列
int main()
{list<tianci::string> lt1;// 传左值，跟push_back⼀样，走拷贝构造tianci::string s1("111111111111");lt1.emplace_back(s1);cout << "*********************************" << endl;// 右值，跟push_back一样，走移动构造lt1.emplace_back(move(s1));cout << "*********************************" << endl;// 直接把构造string参数包往下传，直接用string参数包构造string// 这里达到的效果是push_back做不到的lt1.emplace_back("111111111111");cout << "*********************************" << endl;list<pair<tianci::string, int>> lt2;// 跟push_back⼀样// 构造pair + 拷贝/移动构造pair到list的节点中data上pair<tianci::string, int> kv("苹果", 1);lt2.emplace_back(kv);cout << "*********************************" << endl;// 跟push_back⼀样lt2.emplace_back(move(kv));cout << "*********************************" << endl;////////////////////////////////////////////////////////////////////// 直接把构造pair参数包往下传，直接用pair参数包构造pair// 这里达到的效果是push_back做不到的lt2.emplace_back("苹果", 1);cout << "*********************************" << endl;// 注意，push_back不支持("苹果", 1)这样写// push_back必须加个中括号走隐式类型转换// lt2.push_back({"苹果", 1})  //正确写法// emplace_back不支持({"苹果", 1})这样写// 因为编译器无法从该初始化列表自动推导元素类型并匹配构造函数参数// 说白了，就是识别不出initializer_list还是pair<>// lt2.emplace_back("苹果", 1)  //正确写法return 0;
}

5>新的类功能

a.默认的移动构造和移动赋值

• 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷⻉构造函数/拷⻉赋值重载/取地址重载/const取地址重载，最后重要的是前4个，后两个⽤处不⼤，默认成员函数就是我们不写编译器会⽣成⼀个默认的。C++11新增了两个默认成员函数，移动构造函数和移动赋值运算符重载

• 如果你没有⾃⼰实现移动构造函数，且没有实现析构函数 、拷⻉构造、拷⻉赋值重载中的任意⼀个。那么编译器会⾃动⽣成⼀个默认移动构造。默认⽣成的移动构造函数，对于内置类型成员会执⾏逐成员按字节拷⻉，⾃定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调⽤移动构造，没有实现就调⽤拷⻉构造

• 如果你没有⾃⼰实现移动赋值重载函数，且没有实现析构函数 、拷⻉构造、拷⻉赋值重载中的任意⼀个，那么编译器会⾃动⽣成⼀个默认移动赋值。默认⽣成的移动构造函数，对于内置类型成员会执⾏逐成员按字节拷⻉，⾃定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调⽤移动赋值，没有实现就调⽤拷⻉赋值。(默认移动赋值跟上⾯移动构造完全类似)

• 如果你提供了移动构造或者移动赋值，编译器不会⾃动提供拷⻉构造和拷⻉赋值

class Person
{
public:Person(const char* name = "", int age = 0): _name(name), _age(age){}
private:tianci::string _name;int _age;
};int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);Person s4;s4 = std::move(s2);return 0;
}

b.成员变量声明时给缺省值

成员变量声明时给缺省值是给初始化列表⽤的，如果没有显⽰在初始化列表初始化，就会在初始化列表⽤这个却绳⼦初始化（这个在类和对象这篇文章中介绍过）

c.defult和delete

• C++11可以让你更好的控制要使⽤的默认函数。假设你要使⽤某个默认的函数，但是因为⼀些原因这个函数没有默认⽣成。⽐如，我们提供了拷⻉构造，就不会⽣成移动构造了，那么我们可以使⽤default关键字显⽰指定移动构造⽣成

• 如果能想要限制某些默认函数的⽣成，在C++98中，是该函数设置成private，并且只声明补丁而已，这样只要其他⼈想要调⽤就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指⽰编译器不⽣成对应函数的默认版本，称=delete修饰的函数为删除函数

class Person
{
public :Person(const char* name = "", int age = 0): _name(name), _age(age){}Person(const Person& p):_name(p._name), _age(p._age){}Person(Person&& p) = default;//Person(const Person& p) = delete;
private:tianci::string _name;int _age;
};int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);return 0;
}

d.final和override

final 用于禁止派生类重写虚函数或禁止类被继承，override 用于显式标记虚函数重写以避免错误（这个在多态这篇文章中介绍过）

6>STL中的变化

• 下面圈起来的就是STL中的新容器，但是实际最有⽤的是unordered_map和unordered_set。另外我也有一篇文章单独介绍这两个容器，其它的⼤家了解⼀下即可

• STL中容器的新接⼝也不少，最重要的就是右值引⽤和移动语义相关的push/insert/emplace系列接⼝和移动构造和移动赋值，还有initializer_list版本的构造等，还有⼀些⽆关痛痒的如cbegin/cend等需要时查查⽂档即可

• 容器的范围for遍历，这个在容器部分也介绍过

7>lambda

a.lambda表达式语法

• lambda表达式本质是⼀个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。lambda表达式语法使⽤层⽽⾔没有类型，所以我们⼀般是⽤auto或者模板参数定义的对象去接收lambda对象

• lambda表达式的格式：[capture-list] (parameters)-> return type {function boby }

• [capture-list]: 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下⽂中的变量供lambda函数使⽤，捕捉列表可以传值和传引⽤捕捉。捕捉列表为空也不能省略

• (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 bit" << 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;
}

b.捕捉列表

• lambda表达式中默认只能⽤lambda函数体和参数中的变量，如果想⽤外层作⽤域中的变量就需要进⾏捕捉

• 第⼀种捕捉⽅式是在捕捉列表中显⽰的传值捕捉和传引⽤捕捉，捕捉的多个变量⽤逗号分割。[x，y， &z]表⽰x和y值捕捉，z引⽤捕捉

• 第⼆种捕捉⽅式是在捕捉列表中隐式捕捉，我们在捕捉列表写⼀个=表⽰隐式值捕捉，在捕捉列表写⼀个&表⽰隐式引⽤捕捉，这样我们lambda表达式中⽤了那些变量，编译器就会⾃动捕捉那些变量

• 第三种捕捉⽅式是在捕捉列表中混合使⽤隐式捕捉和显⽰捕捉。[=, &x]表⽰其他变量隐式值捕捉，x引⽤捕捉；[&, x, y]表⽰其他变量引⽤捕捉，x和y值捕捉。当使⽤混合捕捉时，第⼀个元素必须是&或=，并且&混合捕捉时，后⾯的捕捉变量必须是值捕捉，同理=混合捕捉时，后⾯的捕捉变量必须是引⽤捕捉

• lambda表达式如果在函数局部域中，他可以捕捉lambda位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉，lambda表达式中可以直接使⽤。这也意味着lambda表达式如果定义在全局位置，捕捉列表必须为空

• 默认情况下，lambda捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改，mutable加在参数列表的后⾯可以取消其常量性，也就说使⽤该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。使⽤该修饰符后，参数列表不可省略（即使参数为空）

int x = 0;
// 捕捉列表必须为空，因为全局变量不用捕捉就可以用，没有可被捕捉的变量
auto func = [](){x++;};int main()
{// 只能用当前lambda局部域和捕捉的对象和全局对象int a = 0, b = 1, c = 2, d = 3;auto func1 = [a, &b]{// 值捕捉的变量不能修改，引用捕捉的变量可以修改//a++;b++;int ret = a + b;return ret;};cout << func1() << endl;// 隐式值捕捉// 用了哪些变量就捕捉哪些变量auto func2 = [=]{int ret = a + b + c;return ret;};cout << func2() << endl;// 隐式引用捕捉// 用了哪些变量就捕捉哪些变量auto func3 = [&]{a++;c++;d++;};func3();cout << a << " " << b << " " << c << " " << d << endl;// 混合捕捉1auto func4 = [&, a, b]{//a++;//b++;c++;d++;return a + b + c + d;};func4();cout << a << " " << b << " " << c << " " << d << endl;// 混合捕捉2auto func5 = [=, &a, &b]{a++;b++;/*c++;d++;*/return a + b + c + d;};func5();cout << a << " " << b << " " << c << " " << d << endl;// 局部的静态和全局变量不能捕捉，也不需要捕捉static int m = 0;auto func6 = []{int ret = x + m;return ret;};// 传值捕捉本质是⼀种拷贝,并且被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;
}

c.lambda的应用

• 在此之前，我们使⽤的可调⽤对象只有函数指针和仿函数对象，函数指针的类型定义起来⽐较⿇烦，仿函数要定义⼀个类，相对会⽐较⿇烦。使⽤lambda去定义可调⽤对象，既简单⼜⽅便

• lambda在很多其他地⽅⽤起来也很好⽤。⽐如线程中定义线程的执⾏函数逻辑，智能指针中定制删除器等，lambda的应⽤还是很⼴泛的

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 } };// 类似这样的场景，我们实现仿函数对象或者函数指针⽀持商品中// 不同项的⽐较，相对还是⽐较⿇烦的，那么这⾥lambda就很好⽤了sort(v.begin(), v.end(), ComparePriceLess());sort(v.begin(), v.end(), ComparePriceGreater());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;
}

d.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;// lambdaauto r2 = [rate](double money, int year) {return money * rate * year;};// 函数对象Rate r1(rate);r1(10000, 2);r2(10000, 2);auto func1 = [] {cout << "hello world" << endl;};func1();return 0;
}

    // lambdaauto r2 = [rate](double money, int year) {return money * rate * year;};
// 捕捉列表的rate，可以看到作为lambda_1类构造函数的参数传递了，这样要拿去初始化成员变量
// 下面operator()中才能使用
00D8295C lea   eax, [rate]
00D8295F push  eax
00D82960 lea   ecx, [r2]
00D82963 call  `main'::`2': : <lambda_1>::<lambda_1> (0D81F80h)// 函数对象Rate r1(rate);
00D82968 sub    esp, 8
00D8296B movsd  xmm0, mmword ptr[rate]
00D82970 movsd  mmword ptr[esp], xmm0
00D82975 lea    ecx, [r1]
00D82978 call   Rate::Rate(0D81438h)r1(10000, 2);
00D8297D push   2
00D8297F sub    esp, 8
00D82982 movsd  xmm0, mmword ptr[__real@40c3880000000000(0D89B50h)]
00D8298A movsd  mmword ptr[esp], xmm0
00D8298F lea    ecx, [r1]
00D82992 call   Rate::operator() (0D81212h)// 汇编层可以看到r2 lambda对象调用本质还是调用operator()，类型是lambda_1,这个类型名
// 的规则是编译器自己定制的，保证不同的lambda不冲突r2(10000, 2);
00D82999 push    2
00D8299B sub     esp, 8
00D8299E movsd   xmm0, mmword ptr[__real@40c3880000000000(0D89B50h)]
00D829A6 movsd   mmword ptr[esp], xmm0
00D829AB lea     ecx, [r2]
00D829AE call    `main'::`2': : <lambda_1>::operator() (0D824C0h)

8.包装器

a.function

template <class T>
class function; // undefinedtemplate <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的原型，他被定义<functional>头⽂件中。https://zh.cppreference.com/w/cpp/utility/functional/function是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;// 包装普通成员函数// 普通成员函数还有一个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以function<double(Plus*, double, double)> f5 = &Plus::plusd;Plus pd;cout << f5(&pd, 1.1, 1.1) << endl;function<double(Plus, double, double)> f6 = &Plus::plusd;cout << f6(pd, 1.1, 1.1) << endl;cout << f6(pd, 1.1, 1.1) << endl;function<double(Plus&&, double, double)> f7 = &Plus::plusd;cout << f7(move(pd), 1.1, 1.1) << endl;cout << f7(Plus(), 1.1, 1.1) << endl;return 0;
}

150. 逆波兰表达式求值 - 力扣（LeetCode）

b.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也在<functional>这个头⽂件中

• 调⽤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 :static int plusi(int a, int b){return a + b;} double plusd(double a, double b){return a + b;}
};int main()
{auto sub1 = bind(Sub, _1, _2);cout << sub1(10, 5) << endl;// bind本质返回的⼀个仿函数对象// 调整参数顺序（不常用）// _1代表第一个实参// _2代表第二个实参// ...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)> f6 = &Plus::plusd;Plus pd;cout << f6(move(pd), 1.1, 1.1) << endl;cout << f6(Plus(), 1.1, 1.1) << endl;// bind⼀般用于，绑死一些固定参数function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);cout << f7(1.1, 1.1) << endl;// 计算复利的lambdaauto func1 = [](double rate, double money, int year)->double {double ret = money;for (int i = 0; i < year; i++){ret += ret * rate;}return ret - money;};// 绑死⼀些参数，实现出⽀持不同年华利率，不同⾦额和不同年份计算出复利的结算利息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_2_5 = bind(func1, 0.025, _1, 10);function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);cout << func3_1_5(1000000) << endl;cout << func5_1_5(1000000) << endl;cout << func10_2_5(1000000) << endl;cout << func20_3_5(1000000) << endl;return 0;
}

本篇文章到这里就结束啦，希望这些内容对大家有所帮助！

下篇文章见，希望大家多多来支持一下！

感谢大家的三连支持！