---

这一篇比较简短，只是因为后要写异常和智能指针，所以就把它单独放在了一篇博客，后面新开几篇博客来写异常和智能指针

包装器

1、functional

包装器是一个类模板，对可调用对象类型进行再封装适配，可调用对象，比如函数指针，lambda等。包装器的头文件是functional。

template <class T> function;
template <class Ret, class... Args>
class function<Ret(Args...)>
模板参数说明:
Ret:被调用函数的返回类型
Args...:被调用函数的形参

实际使用

int f(int a, int b)
{
	cout << "f" << endl;
	return a + b;
}

struct Functor
{
public:
	int operator() (int a, int b)
	{
		cout << "Functor" << endl;
		return a + b;
	}
};

int main()
{
	//int(*pf1)(int, int) = f;函数指针
	function<int(int, int)> f1 = f;
	function<int(int, int)> f2 = Functor();
	function<int(int, int)> f3 = [](int a, int b) {
		cout << "lambda" << endl;
		return a + b; 
	};
	cout << f1(1, 2) << endl;
	cout << f2(10, 20) << endl;
	cout << f3(100, 200) << endl;
	return 0;
}

三个int，第一个是函数返回值类型，后两个是参数类型。包装起包装起来的就可以传给模板参数

	map<string, function<int(int, int)>> opFuncMap;
	opFuncMap["函数指针"] = f1;
	opFuncMap["仿函数"] = Functor();
	opFuncMap["lambda"] = [](int a, int b) {
		cout << "lambda" << endl;
		return a + b;
	};
	cout << opFuncMap["lambda"](1, 2) << endl;

看一个题

逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用32位整数表示。

之前的写法

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(auto& str : tokens)
        {
            if(str == "+" || str == "-" || str == "/" || str == "*")
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                switch(str[0])
                {
                    case '+':
                        st.push(left+right);
                        break;
                    case '-':
                        st.push(left-right);
                        break;
                    case '*':
                        st.push(left*right);
                        break;
                    case '/':
                        st.push(left/right);
                        break;
                }
            }
            else
            {
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

用包装器后

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string, function<int(int, int)>> opFuncMap = 
        {
            {"+", [](int a, int b){return a + b; }},
            {"-", [](int a, int b){return a - b; }},
            {"*", [](int a, int b){return a * b; }},
            {"/", [](int a, int b){return a / b; }}
        };//这里就是map的初始化，用C++11的列表初始化
        for(auto str : tokens)
        {
            if(opFuncMap.count(str))
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                st.push(opFuncMap[str](left, right));
            }
            else
            {
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

包装器也可以包装成员函数。

class Plus
{
public:
	static int plus1(int a, int b)
	{
		return a + b;
	}
	double plus2(double a, double b)
	{
		return (a + b) * _rate;
	}
private:
	int _rate = 2;
};

int main()
{
class Plus
{
public:
	Plus(int rate = 2)
		:_rate(rate)
	{}
	static int plus1(int a, int b)
	{
		return a + b;
	}
	double plus2(double a, double b)
	{
		return (a + b) * _rate;
	}
private:
	int _rate = 2;
};

int main()
{
	function<int(int, int)> f1 = Plus::plus1;
	function<int(Plus, double, double)> f2 = &Plus::plus2;
	cout << f1(1, 2) << endl;
	cout << f2(Plus(), 20, 20) << endl;
	Plus p1(3);
	cout << f2(p1, 20, 20) << endl;
    return 0;
}

静态成员函数可以直接调用，而非静态的需要在第一个位置加上类名，因为有this指针，然后后面的Plus前加上&，静态函数也可以加上这个&，使用这个函数的时候，非静态需要在第一个参数位置放上类的对象，可以是匿名对象，如果在声明f2时，传的是*Plus，那么下面调用时就必须传对象的地址，所以就不能传匿名对象的地址，因为右值无法取地址。

包装器本质上是仿函数，f1，f2，f3就是对象，然后调用operator()，传过去参数，然后operator()再去调用对应函数，传类的对象就用对象来调用，传指针就指针来调用。

2、绑定

绑定是一个函数模板，用来调整参数。绑定是一个通用的函数适配器，接受一个可调用对象，可调用对象就是三个，函数指针、lambda、仿函数，生成一个新的可调用对象来适配。

bind函数第一个参数是一个万能引用，左右值都可传，然后后面的是占位符，_1表示第一个参数，_2表示第二个参数，以此类推，这些占位符是一个placeholders空间里。

int Print(int a, int b)
{
	cout << a << " ";
	cout << b << endl;
}

int main()
{
	Print(10, 20);
	auto RP = bind(Print, placeholders::_2, placeholders::_1);
	RP(10, 20);//再次调用就换了顺序了。
	return 0;
}

如果bind写着_1在_2前面，那就没换顺序，要换顺序占位符就得对应着写。bind函数会返回一个对象，我们可以用auto来推演类型，还可以用function<void(int, int)>。实际调用的还是Print，不过适配器就是套了一个壳。

绑定真正有用的是改变参数个数

用这段代码做例子

class Sub
{
public:
	Sub(int rate)
		:_rate(rate)
	{}

	int func(int a, int b)
	{
		return (a - b) * _rate;
	}
private:
	int _rate;
};

class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		stack<int> st;
		map<string, function<int(int, int)>> opFuncMap =
		{
			{"+", [](int a, int b) {return a + b; }},
			{"-", [](int a, int b) {return a - b; }},
			{"*", [](int a, int b) {return a * b; }},
			{"/", [](int a, int b) {return a / b; }}
		};//这里就是map的初始化，用C++11的列表初始化
		for (auto str : tokens)
		{
			if (opFuncMap.count(str))
			{
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();
				st.push(opFuncMap[str](left, right));
			}
			else
			{
				st.push(stoi(str));
			}
		}
		return st.top();
	}
};

int main()
{
	function<int(Sub, int, int)> fSub = &Sub::func;
	fSub(Sub(1), 10, 20);
	return 0;
}

这是上面包装器的写法。这样的写法无法给opFuncMap传fSub对象，因为参数个数不一致，这时候就是绑定的作用体现了。

	function<int(int, int)> fSub = bind(&Sub::func, Sub(1), placeholders::_1, placeholders::_2);
	fSub(10, 20);

把Sub(1)对象显式地传给func函数，顺序没有变，只是第一个参数显示传，剩下两个就从_1开始排顺序。也可以对其他参数来绑定。

	function<int(int, int)> fSub = bind(&Sub::func, placeholders::_1, 10, placeholders::_2);
	fSub(Sub(1), 20);

本篇gitee

结束。