目录
一，可变参数模板
1. 递归方法展开参数包
2. 逗号表达式展开参数包
3，可变参数模板优势
二，lambda表达式
1. lambda表达式语法
2. 注意点
三，包装器
1. bind(了解)
嗨！收到一张超美的风景图，希望你每天都能顺心！
一，可变参数模板
由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现阶段呢，我们掌握一些基础的可变参数模板特性。
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。
1. 递归方法展开参数包
template <class T>
void func(const T& t)
{
cout << t << endl;
cout << endl;
}
void func()
{
cout << 0 << endl;
}
template<class T , class ...Ags>
//void func(const T& t, Ags... args) // 一个一个地解包参数
void func(const T& t, Ags&&... args) //
{
cout << t << " 剩余包数：" << sizeof...(args) << endl ;
//func(args...); // 剩余参数包
func(forward<Ags>(args)...); //...的位置有讲究，
}
int main()
{
func();
func(1, 'A');
func(1, 'A', "hello word");
}2. 逗号表达式展开参数包
template <class T>
void PrintArg(T t) // 参数处理函数
{
cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
int arr[] = { (PrintArg(args), 0)... };
cout << endl;
}
int main()
{
ShowList(1);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof... (Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。
3，可变参数模板优势
vector<pair<int, string>> it;
it.emplace_back(1, "sort", 2, "sort", 3, "sort");
it.emplace_back(1,"sort");
it.push_back(make_pair(1, "sort"));
it.push_back({1,"sort"});
// 优势：emplace_back直接构造；push_back需要2次构造虽然只是减少了一次构造，但push_back的功能emplace_back都有，而且后者还具备一些优势。
二，lambda表达式
1. lambda表达式语法
lambda
表达式书写格式：
[capture-list] (parameters) mutable -> return-type { statement }
[capture-list] : 捕捉列表 ，该列表总是出现在 lambda 函数的开始位置， 编译器根据 [] 来 判断接下来的代码是否为 lambda 函数 ， 捕捉列表能够捕捉上下文中的变量供 lambda 函数使用 。(parameters) ：参数列表。与 普通函数的参数列表一致 ，如果不需要参数传递，则可以连同() 一起省略mutable ： 默认情况下， lambda 函数总是一个 const 函数， mutable 可以取消其常量性。使用该修饰符时，参数列表不可省略( 即使参数为空 ) 。->returntype ：返回值类型 。用 追踪返回类型形式声明函数的返回值类型 ，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导 。{statement} ：函数体 。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。注意：
在
lambda
函数定义中，
参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为
空
。因此
C++11
中
最简单的
lambda
函数为：
[]{}
;
该
lambda
函数不能做任何事情。
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝",1.5, 4 } };
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; });
// lambda的一个优势：面对简单的仿函数，就地建立，省去了寻找仿函数那一步。
// 传值捕捉-——是捕捉对象的拷贝
int x = 0, y = 1;
auto swap = [x,y]() mutable //捕捉对象是不被修改的常性 + mutacble可以修改捕捉对象，但无法修改外部对象
{ auto temp = x;
x = y;
y = temp;
}
// 引用捕捉——不加mutable 可以修改外部对象
auto swap2 = [&x, &y](){
auto temp = x;
x = y;
y = temp;
}
// 全传值捕捉 & 全引用
auto swaps = [=]()
// auto swaps = [&]()
{...}
}2. 注意点
a.
父作用域指包含
lambda
函数的语句块。
b.
语法上捕捉列表可由多个捕捉项组成，并以逗号分割
。 比如：[=, &a, &b]
：以引用传递的方式捕捉变量
a
和
b
，值传递方式捕捉其他所有变量[&，
a, this]
：值传递方式捕捉变量
a
和
this
，引用方式捕捉其他变量。
c.
捕捉列表不允许变量重复传递，否则就会导致编译错误
。比如：[=, a]
：
=
已经以值传递方式捕捉了所有变量，捕捉
a
重复。
d.
在块作用域以外的
lambda
函数捕捉列表必须为空
。
e.
在块作用域中的
lambda
函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
f. lambda 表达式之间不能相互赋值 ，即使看起来类型相同。
总之，lamda本质上是一个仿函数
三，包装器
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
包装器本质上是创建仿函数，进行调用函数例子：
int func(int x, int y)
{
return x + y;
}
class fun
{
public:
int operator()(int x, int y)
{
return x * y;
}
};
class plusi
{
public:
int Add_plus(int a, int b)
{
return a + b;
}
static int Add(int a, int b)
{
return a + b;
}
};
int main()
{
function<int(int, int)> f1 = func; // 函数指针
function<int(int, int)> f2 = fun(); // 仿函数
function<int(int, int)> f3 = [](int x, int y) {return x + y; }; // lambda表达式
function<int(int, int)> f4 = plusi::Add; // 静态成员函数
function<int(plusi,int, int)> f5 = &plusi::Add_plus; //Add_plus参数中存在隐藏的this指针,但添加的不是plusi指针。
// 为什么是 plusi,而不是plusi*, 原因：f5(plusi(),2, 3), 如果是指针，那么无法使用匿名对象。
// 且f1,f2,f3类型相同
// 利用键值对进行映射
map < string, function<int(int, int)>>mp;
mp["函数指针"] = f1;
mp["仿函数"] = f2;
mp["lambda表达式"] = f3;
cout << f1(1, 2) << endl;
cout << f2(1, 2) << endl;
cout << f3(1, 2) << endl;
cout << f5(plusi(),2, 3) << endl;
return 0;
}
}尝试使用包装器来解题：
150. 逆波兰表达式求值 - 力扣（LeetCode）
1. bind(了解)
std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。
功能： 1. 调整参数顺序（了解） 2.调整参数个数（使用较多）
int func(int x, int y)
{
return x / y;
}
class print
{
public:
int multiply(int x, int y)
{
return x * y;
}
};
int main()
{
// 1.调整形参顺序
auto Pfunc1 = bind(func, placeholders::_1, 2); // 交换形参，_1存在于placeholders命名空间中
cout << Pfunc1(10, 2) << endl; // 5 其中第三个参数为2，可以理解为Pfunc1函数，第三参数一直是2，我叫他“绑死”“显示传递”
auto Pfunc2 = bind<int>(func, placeholders::_2, placeholders::_1); // 重新修改形参的新函数
cout << Pfunc2(2, 10) << endl; // 0.5
// 2.调整形参个数
map<string, function<int(int, int)>> mp;
mp["调整形参顺序"] = Pfunc1;
function<int(print, int,int)> Pfunc3 = &print::multiply; // 三个参数无法载入map中
auto Pfunc4 = bind(Pfunc3, print(), placeholders::_1, placeholders::_2); //通过bind显示传递（绑死），减少传参个数
mp["调整形参个数"] = Pfunc4;
return 0;
}结语
本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力。
![BUUCTF---[极客大挑战 2019]Http1](https://img-blog.csdnimg.cn/direct/e5dbb05113344d178bdcce4ee79df072.png)
