【C++11特性篇】玩转C++11中的包装器（function＆bind）

前言

大家好吖，欢迎来到 YY 滴C++系列，热烈欢迎！本章主要内容面向接触过C++的老铁
主要内容含：

欢迎订阅 YY滴C++专栏！更多干货持续更新！以下是传送门！

一.为什么需要包装器function？
二.function包装器
- 【1】function基本语法一览
- 【2】function解决可调用对象的类型问题——>把可调用对象包装器来，存放到数组中去
三.包装器，解决模板的效率低下，同一函数模板实例化多份的问题
四.包装器的一个具体应用oj题：逆波兰表达式（利用map+function来解决）
五.bind（绑定包装器）
- 【1】基本概念
- 【2】bind实现参数顺序调整的规则示意图
- 【3】bind的一个基本应用场景：不同利率计算（引入变量rate）
- 【4】placeholders::_1, placeholders::_2无视bind函数包装器的常量位置：按顺序1，2，3...
- 【5】bind绑定成员函数（静态/非静态）

一.为什么需要包装器function？

我们可以观察下面这段代码，我们会发现我们难以判断func( )到底是什么
因为其有可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象
为了方面管理这些【不同的可调用对象的类型问题】 ，我们引入了 function

ret = func(x);

template<class F, class T>
T useF(F f, T x)
{
    static int count = 0;
    cout << "count:" << ++count << endl;
    cout << "count:" << &count << endl;

    return f(x);
}

double f(double i)
{
    return i / 2;
}

struct Functor
{
    double operator()(double d)
    {
        return d / 3;
    }
};

int main()
{
	// 函数指针
	cout << useF(f, 11.11) << endl;

	// 函数对象
	cout << useF(Functor(), 11.11) << endl;

	// lambda表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;

	return 0;
}

二.function包装器

【1】function基本语法一览

std::function在头文件<functional>
// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

【2】function解决可调用对象的类型问题——>把可调用对象包装器来，存放到数组中去

function包装器也叫作 适配器
C++中的function本质是一个 类模板
在以往的学习中，面对不同的可调用对象，我们希望能把他们放到一个vector中方便调用，但是类型不同显然做不到
而function包装器就恰好解决了这个问题（可调用对象的类型问题）

如在下面代码中，第一部分ret = func(x);（可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象）
我们通过function语法即可成功把他们放到vector中

template<class F, class T>
T useF(F f, T x)
{
    static int count = 0;
    cout << "count:" << ++count << endl;
    cout << "count:" << &count << endl;

    return f(x);
}

double f(double i)
{
    return i / 2;
}

struct Functor
{
    double operator()(double d)
    {
        return d / 3;
    }
};

int main()
{
	// 函数指针
	cout << useF(f, 11.11) << endl;

	// 函数对象
	cout << useF(Functor(), 11.11) << endl;

	// lambda表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;

	// 可调用对象存储到容器中
	//vector<>

	// 包装器 -- 可调用对象的类型问题
	//function<返回值类型(参数类型)>
	function<double(double)> f1 = f;// 函数名
	function<double(double)> f2 = [](double d)->double { return d / 4; };// 函数对象
	function<double(double)> f3 = Functor();// lamber表达式

	//vector<function<double(double)>> v = { f1, f2, f3 };//写法一
	//我们 通过function语法即可成功把他们放到vector中 
	vector<function<double(double)>> v = { f, [](double d)->double { return d / 4; }, Functor() };//写法二

	double n = 3.3;
	for (auto f : v)
	{
		cout << f(n++) << endl;//遍历vector，每个元素是一个包装器
	}

	return 0;
}

三.包装器，解决模板的效率低下，同一函数模板实例化多份的问题

我们观察下面代码
count 是一个静态局部变量，它确实存储在静态存储区域。
静态局部变量在程序生命周期内只被初始化一次，然后保留其值直到程序结束。因此，从理论上讲，count 应该在整个程序运行过程中保持唯一的值。然而，我们在 main 函数中使用了三个不同的函数对象（函数名、函数对象和 lambda 表达式），每个都调用了 useF 函数， 实例化了三份useF函数 ，因此count值不会增加，还是1；

经过包装器包装后，我们再来看这段代码：
我们发现，useF函数 只被实例化成了一份

四.包装器的一个具体应用oj题：逆波兰表达式（利用map+function来解决）

逆波兰表达式oj链接：传送门
题目一览：

分析：我们原本用栈来完成，现在我们可以用map+function来解决
改进后，用function把lambda表达式包装起来了
lambda相关博客传送门：【C++11特性篇】lambda表达式玩法全解

五.bind（绑定包装器）

【1】基本概念

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表
一般主要应用于：实现参数顺序调整等操作

【2】bind实现参数顺序调整的规则示意图

如图中所示：
同样的rSub（10，5）通过变换bind 函数包装器中placeholders::_1, placeholders::_2，可以实现10-5＆5-10

【3】bind的一个基本应用场景：不同利率计算（引入变量rate）

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

int main()
{
	function<double(int, int)> Plus1 = bind(Plus, placeholders::_1, placeholders::_2, 4.0);
	function<double(int, int)> Plus2 = bind(Plus, placeholders::_1, placeholders::_2, 4.2);
	function<double(int, int)> Plus3 = bind(Plus, placeholders::_1, placeholders::_2, 4.4);

	cout << Plus1(5, 3) << endl;
	cout << Plus2(5, 3) << endl;
	cout << Plus3(5, 3) << endl;
	return 0;
}

【4】placeholders::_1, placeholders::_2无视bind函数包装器的常量位置：按顺序1，2，3…

如下图所示：
即使rate参数放在bind包装器的中间，依然按照placeholders::_1，_2，_3…的顺序走

double Plus(int a, double rate，int b)
{
	return (a + b) * rate;
}

int main()
{
	function<double(int, int)> Plus1 = bind(Plus, placeholders::_1,  4.0 placeholders::_2);
	function<double(int, int)> Plus2 = bind(Plus, placeholders::_1, 4.2,placeholders::_2);
	function<double(int, int)> Plus3 = bind(Plus, placeholders::_1,4.4 ,placeholders::_2);

	cout << Plus1(5, 3) << endl;
	cout << Plus2(5, 3) << endl;
	cout << Plus3(5, 3) << endl;
	return 0;
}

【5】bind绑定成员函数（静态/非静态）

主要方法分为下面三种：

对于静态成员函数，直接取类的地址即可&SubType::sub
对于非静态成员函数，在直接取类的地址的基础上&SubType::sub，法一：先实例化出一个类SubType st;，取其地址&st
在直接取类的地址的基础上&SubType::sub，法二：直接传入一个匿名对象SubType()

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

	int ssub(int a, int b, int rate)
	{
		return (a - b) * rate;
	}
};

int main()
{
//对于静态成员函数
	function<double(int, int)> Sub1 = bind(&SubType::sub, placeholders::_1, placeholders::_2);
		cout << Sub1(1, 2) << endl;
//对于非静态成员函数，法一
	  SubType st;
	function<double(int, int)> Sub2 = bind(&SubType::ssub, &st, placeholders::_1, placeholders::_2, 3);
    	cout << Sub2(1, 2) << endl;
//对于非静态成员函数，法二
	function<double(int, int)> Sub3 = bind(&SubType::ssub, SubType(), placeholders::_1, placeholders::_2, 3);
    	cout << Sub3(1, 2) << endl;
 
	return 0;
}