C++11常用知识（下）【可变参数模板 || lambda表达式 || 包装器】

目录

一，可变参数模板

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;
   }

结语

   本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力。