一、包装器的引入

在C++中我们的可调用对象是很多的，例如函数指针，仿函数，lambda表达式，这多的可调用对象极大的丰富了C++的功能，但是也给我们带来了一些麻烦，例如在模板中，我们需要一个参数确定的可调用对象作为类型时，如果我们选择传递函数指针，就会得到一份关于函数指针的模板函数，传递的是一个仿函数，就会得到一份关于仿函数的模板函数，传递的是lambda表达式，就会得到一份关于lambda的模板函数。但是这些可调用对象是非常相似的，我们的模板却生成了3份函数，导致模板的效率低下！为了解决这个问题C++11引入了包装器，如果可调用对象的签名式相同那么它们就可以呈现出一个统一的类型。

下面是不使用包装器的模板

template<class F, class T>
T useF(F f, T x)
{
	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;
	// lamber表达式 ---> 实例化一份函数对象类型
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
	return 0;
}

二、包装器的介绍

std::function在头文件

// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

如果我们要包装一个函数只要这样书写，包装后定义出的对象使用的还是包装前的可调用对象。

function<返回值(参数，参数，参数...)>

上面的代码经过包装器包装，模板只会生成一份函数

#include <functional>
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()
{
	// 对函数名进行包装
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;
	// 对函数对象进行包装
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;
	// 对lamber表达式进行包装
	std::function<double(double)> func3 = [](double d)->double { return d / 4; };
	cout << useF(func3, 11.11) << endl;
	
	return 0;
}

可以看出通过function对C++中各种可调用实体（普通函数、Lambda表达式、仿函数）的封装，形成一个新的可调用的function对象，让我们不再纠结那么多可调用的实体，有种“万众归一”，一切变得简单的感觉。

此外包装器也可以包装成员函数，但是如果包装非静态的成员函数：

被包装的成员函数前面要加&，而且第一个参数要传递类的类型，
在调用时第一个参数要传递一个类对象，由这个类对象去调用成员函数。

 //function 对成员函数进行包装
class Plus
{
public:
	Plus(int factor = 2)
		:_factor(factor)
	{}
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return (a + b) * 2;
	}
private:
	int _factor;
};

int main()
{
	function<int(int, int)> f1 = Plus::plusi;
	// 非静态成员函数前面要加&
	function<double(Plus*, double, double)> f2 = &Plus::plusd;

	cout << f1(1, 2) << endl;
	cout << f2(Plus(), 1, 2) << endl;
}

三、bind函数的介绍

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

在这里插入图片描述

调用bind的一般形式：auto newCallable = bind(callable,arg_list);

newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。
arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是占位符，表示newCallable的参数，它们占据了传递给callable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为callable的第一个参数，_2为第二个参数，以此类推。
这些占位符在一个叫placeholders的一个命名空间内！

功能1：改变参数的顺序

int sub(int x, int y)
{
	return x - y;
}

int main()
{
	cout << sub(10, 5) << endl;
	// 调整参数的位置
	auto newsub = bind(sub, placeholders::_2, placeholders::_1);
	// 或者这样写也许
	//function<int(int,int)> func = bind(sub, placeholders::_2, placeholders::_1);
	cout << newsub(10, 5) << endl;
}

在这里插入图片描述

功能2：改变参数的个数

类内成员要传递三个参数，我们直接让第一个参数固定绑死！这样我们的新函数就可以只传递两个参数了

class Plus
{
public:
	Plus(int factor = 2)
		:_factor(factor)
	{}
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return (a + b) * 2;
	}
private:
	int _factor;
};

int main()
{
	auto newplusd = bind(&Plus::plusd, Plus(3), placeholders::_1, placeholders::_2);
	cout << newplusd(1, 2) << endl;
}

在这里插入图片描述

又例如我们进行这样的特殊绑定，绑定第2个参数

class Plus
{
public:
	Plus(int factor = 2)
		:_factor(factor)
	{}
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return (a + b) * 2;
	}
private:
	int _factor;
};

int main()
{
	auto newplusd = bind(&Plus::plusd, placeholders::_1, 1, placeholders::_2);
	cout << newplusd(Plus(3), 2) << endl;
}