前言：

       我们上一章一节已经接触了C++11的一些特性，本章将继续更深入介绍C++11中其他使用且重要的一些功能。

目录

（一）万能模版和完美转发

1、万能模版

2、完美转发

（二）可变参数模版

1、可变参数模版的使用

2、emplace_back

（三）lambda表达式

1、引入

2、lambda表达式的定义

3、lambda表达式的用法

（四）包装器function及bind绑定

1、包装器

 2、bind绑定

---

（一）万能模版和完美转发

1、万能模版

万能模版样式：

• 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值
• 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力
• 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值

 这里还是太抽象，我们来看一个例子：
 

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }

void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

这段代码的输出结果是：

输出全是左值引用，很显然这并不是我们想要的，因为无论传的是左值还是右值，都将退化成左值。

那怎么解决这一问题呢？？？这就要用到了我们下面讲解的完美转发。

2、完美转发

我们为了解决类似上述场景的问题，希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的：

完美转发：

这里就用到了我们forward的函数模板。

沿用上面的例子我们来看：

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }

void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

//std::forward<T>(t)在传参的过程中保持了t的原生类型属性。

template<typename T>
void PerfectForward(T&& t)
{
	//完美转发，按照原封不动的方式进行转发
	//Fun(t);
	Fun(std::forward<T>(t));
}

int main()
{
	PerfectForward(10);           //右值

	int a;
	PerfectForward(a);            //左值
	PerfectForward(std::move(a)); //右值

	const int b = 8;
	PerfectForward(b);		      //const 左值
	PerfectForward(std::move(b)); //const 右值

	return 0;
}

 运行结果：

C++11新提供的forward函数模板，可以解决上述问题，使得传右值不会退化成左值。

（二）可变参数模版

1、可变参数模版的使用

首先在学C语言的时候，我们用的printf函数是一个可变参数函数，printf从语法上说是可以写多个参数，然后该函数自己识别。

可变参数模版：

解释：

• Args是一个模板参数包，args是一个函数形参参数包
• 声明一个参数包Args…args，这个参数包中可以包含0到任意个模板参数

首先，我们介绍如何参数个数的方法：

template <class ...Args>
void ShowList1(Args... args)
{
	//参数个数
	cout << sizeof...(args) << endl;
}

//不一定非要用Args也可以取别的名字
template <class ...X>
void ShowList2(X... y)
{
	cout << sizeof...(y) << endl;
}

int main()
{
	ShowList1(1, 'x', 1.1);
	ShowList2(1, 2, 3, 4, 5);

	return 0;
}

主要使用sizeof...( )形式来获取参数个数。

那么我们怎么一一获取参数包的值的呢？有下面两种方法：

• emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
• 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
• 可以不传pair，可以直接传参数
• 拿到参数自己构建对象（保证了底层一定是右值 —— 直接去构造的）
   

 对比：

push_back()：

• 参数如果给的是左值是：构造 + 拷贝构造
• 参数如果给的是右值是：构造 + 移动构造
• 函数传值返回也是个右值

emplace_back()：

• 直接构造

两者的底层实现的机制不同。push_back() 向容器尾部添加元素时，首先会创建这个元素，然后再将这个元素拷贝或者移动到容器中（如果是拷贝的话，事后会自行销毁先前创建的这个元素）；而 emplace_back() 在实现时，则是直接在容器尾部创建这个元素，省去了拷贝或移动元素的过程。但其实两者差别并不大。

（三）lambda表达式

1、引入

C++98中，我们会遇到下面这种场景：

 2、bind绑定

简介：

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。 一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

bind是个函数模板，调整了调用对象参数，用来调整个数和顺序，生成一个新的可调用对象：

包装器的特点就是统一了类型，但是值得注意的是包装时一定要注意匹配，如下：

这就在包装时不匹配，所在包装时一定要匹配。

下面的场景我们存一个map，这时就要求function包装器要统一了：

不过不免会有一些特殊情况：

func1和func2是可以的，但是func3就难受了呀，不匹配啊…

此时我们就可以通过bind函数来调整一下参数个数：

还可以调整参数顺序：

 

 详细代码：

#include <functional>
int Plus(int a, int b)
{
	return a + b;
}
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1,
		placeholders::_2);
	//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
	//func2的类型为 function<void(int, int, int)> 与func1类型一样
	//表示绑定函数 plus 的第一，二为： 1， 2
	auto func2 = std::bind(Plus, 1, 2);
	cout << func1(1, 2) << endl;
	cout << func2() << endl;
	Sub s;
	// 绑定成员函数
	std::function<int(int, int)> func3 = std::bind(&Sub::sub, s,
		placeholders::_1, placeholders::_2);
	// 参数调换顺序
	std::function<int(int, int)> func4 = std::bind(&Sub::sub, s, 
	placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	cout << func4(1, 2) << endl;
	return 0;
}

实际例子：

int Div(int a, int b)
{
	return a / b;
}

int Plus(int a, int b)
{
	return a + b;
}

int Mul(int a, int b, double rate)
{
	return a * b * rate;
}

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};

using namespace placeholders;

// 11:50继续
int main()
{
	// 调整个数, 绑定死固定参数
	function<int(int, int)> funcPlus = Plus;
	//function<int(Sub, int, int)> funcSub = &Sub::sub;
	function<int(int, int)> funcSub = bind(&Sub::sub, Sub(), _1, _2);
	function<int(int, int)> funcMul = bind(Mul, _1, _2, 1.5);
	map<string, function<int(int, int)>> opFuncMap =
	{
		{ "+", Plus},
		{ "-", bind(&Sub::sub, Sub(), _1, _2)}
	};

	cout << funcPlus(1, 2) << endl;
	cout << funcSub(1, 2) << endl;
	cout << funcMul(2, 2) << endl;

	cout << opFuncMap["+"](1, 2) << endl;
	cout << opFuncMap["-"](1, 2) << endl;



	int x = 2, y = 10;
	cout << Div(x, y) << endl;

	// 调整顺序 -- 鸡肋
	// _1 _2.... 定义在placeholders命名空间中，代表绑定函数对象的形参，
	// _1，_2...分别代表第一个形参、第二个形参...
	//bind(Div, placeholders::_1, placeholders::_2);
	//auto bindFunc1 = bind(Div, _1, _2);
	//function<int(int, int)> bindFunc2 = bind(Div, _2, _1);
	//cout << bindFunc1(x, y) << endl;
	//cout << bindFunc2(x, y) << endl;



	return 0;
}

感谢您的阅读！