一、function包装器

1. function包装器基本介绍

function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

function的作用是将具有相同调用形式的不同类型的可调用对象进行类型统一。

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

模板参数说明：

Ret：被包装的可调用对象的返回值类型。
Args... ：被包装的可调用对象的形参类型。

2. function包装器统一类型

如下图代码所示，我们有一个函数模板，分别以三种不同的形式进行调用，那么这个函数模板就会实例化出三份useF函数

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;

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

	return 0;
}

从下面的运行结果就可以看到，count的地址是不一样的，因为实例化出了三份useF函数；
useF可能是什么呢？那么useF可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？

所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！

但是C++11有了包装器以后，就发了很大的变化

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

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

struct Functor
{
	int operator()(int a, int b)
	{
		return a * b;
	}

};

class Plus {
public:
	static int plusi(int a, int b) {
		return a + b + 1;
	}
	double plusd(double a, double b) {
		return a + b;
	}
};
int main()
{
	//包装函数指针
	function<int(int, int)> f1 = f;
	cout << "f: " <<  f1(1, 2) << endl;

	//包装仿函数
	function<int(int, int)> f2 = Functor();
	cout << "Functor(): " << f2(1, 2) << endl;

	//包装静态的成员函数
	function<int(int, int)> f3 = Plus::plusi; 
	cout << f3(1, 2) << endl;

	//包装非静态的成员函数---需要在调用的时候多加一个参数
	function<double(Plus, double, double)> f4 = Plus::plusd;
	cout << f4(Plus(), 1.1, 2.2) << endl;

	//包装lamber表达式
	function<int(int, int)> f5 = [](int a, int b)->double { return a * b; };
	cout << f5(1, 5) << endl;

	return 0;
}

3. function包装器的使用场景

逆波兰表达式

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        map<string, function<int(int, int)>> opFuncMap;
        opFuncMap["+"] = [](int a, int b)->int{return a + b;};
        opFuncMap["-"] = [](int a, int b)->int{return a - b;};
        opFuncMap["*"] = [](int a, int b)->int{return a * b;};
        opFuncMap["/"] = [](int a, int b)->int{return a / b;};
        stack<int> s;
        for(size_t i = 0; i < tokens.size(); ++i)
        {
            string& str = tokens[i];
            //str是操作数
            if(opFuncMap.find(str) == opFuncMap.end())
            {
                s.push(stoi(str));
                //s.push(atoi(str.c_str()));
            }
            else
            {
                //str是操作符
                int right = s.top();
                s.pop();
                int left = s.top();
                s.pop();
                s.push(opFuncMap[str](left, right));
            }
        }
        return s.top();
    }
};

二、bind包装器

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

template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

模板参数说明：

fn：可调用对象。
args...：要绑定的参数列表：值或占位符。

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

调用bind的一般形式：
auto newCallable = bind(callable,arg_list);
其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

// 使用举例
#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);//使用auto

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