【 C++11 】包装器
目录
1、function包装器
function包装器的引入
function包装器的概念
使用function包装器优化逆波兰表达式求值
使用function包装器解决模板效率地下，实例化多份的问题
function包装器的意义
2、bind包装器
bind包装器的引入
bind包装器的概念
bind包装器绑定调整参数个数
bind包装器绑定调整参数顺序
bind包装器的意义
1、function包装器
function包装器的引入
来看这样一行代码：
ret = func(x);上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！为什么呢？我们继续往下看
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; }
通过上面的程序验证，我们会发现useF函数模板实例化了三份。每份count的地址都是不一样的。有没有办法让useF函数模板只实例化一份呢？为了让可调用的类型统一起来，C++11引入了function包装器来解决。
function包装器的概念
function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
function类模板的原型如下：
std::function在头文件<functional> // 类模板原型如下 template <class T> function; // undefined template <class Ret, class... Args> class function<Ret(Args...)>; 模板参数说明： Ret : 被调用函数的返回类型 Args…：被调用函数的形参有了function包装器，就可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。示例：
#include <functional> int f(int a, int b) { return a + b; } struct Functor { public: int operator() (int a, int b) { return a + b; } }; class Plus { public: static int plusi(int a, int b) { return a + b; } double plusd(double a, double b) { return a + b; } }; int main() { // 函数名(函数指针) std::function<int(int, int)> func1 = f; cout << func1(1, 2) << endl;//3 // 仿函数 std::function<int(int, int)> func2 = Functor(); cout << func2(10, 20) << endl;//30 // lambda表达式 std::function<int(int, int)> func3 = [](int a, int b) {return a + b; }; cout << func3(15, 25) << endl;//40 //类的静态成员函数 std::function<int(int, int)> func4 = Plus::plusi;//非静态成员函数必须加&，静态可不加 cout << func4(100, 200) << endl;//300 //类的非静态成员函数 std::function<double(Plus, double, double)> func5 = &Plus::plusd;//非静态成员函数必须加&，静态可不加 cout << func5(Plus(), 100.11, 200.11) << endl;//300.22 return 0; }注意：
- 类的成员函数在包装的时候记得指定类域
- 类的非静态成员函数必须加&，静态成员函数可加可不加
- 类的非静态成员函数存在隐含的this指针，包装的时候要多增加一个参数（类名），调用的时候多传一个类的匿名对象
使用function包装器优化逆波兰表达式求值
来看leetcode上这样一道题：逆波兰表达式求值
解决此题的步骤如下：
- 定义一个栈，遍历此数组
- 遍历到数字直接push入栈
- 若遍历到的字符串不是数字（"+"、"-"、"*"、"/"其中任意一个字符串），取栈顶的两个元素进行对应的算数运算，并把结果再push入栈。
- 遍历结束，最终栈顶的元素就是最终的值
代码如下：
class Solution { public: int evalRPN(vector<string>& tokens) { stack<int> st; for (int i = 0; i < tokens.size(); i++) { if (!(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/")) { st.push(stoi(tokens[i])); } else { int num1 = st.top(); st.pop(); int num2 = st.top(); st.pop(); if (tokens[i] == "+") st.push(num1 + num2); else if (tokens[i] == "-") st.push(num2 - num1); else if (tokens[i] == "*") st.push((long)num1 * num2); else if (tokens[i] == "/") st.push(num2 / num1); } } return st.top(); } };
- 上述代码中，我主要是通过if、else语句来判断其进行何种运算，若后续运算类型增加了，那么还要增加if、else语句，多少有点冗余，我们可以使用包装器来优化此代码。
优化规则如下：
- 这里我们可以利用包装器建立操作符和对应函数的映射关系，这一步需要用到map容器，在列表初始化里头对每个操作符完成对应的函数映射关系
- 遍历数组，判断字符是否在map容器里头，如果在，说明是操作符，取栈顶的两个元素，进行相应的运算后，把结果push到栈里。
- 若字符不在map容器里头，说明是操作数，直接入栈
- 遍历结束，最后直接返回栈顶的元素
- 注意要防止栈溢出，要用long long的类型
class Solution { public: int evalRPN(vector<string>& tokens) { stack<long long> st; map<string, function<long long(long long, long long)>> opFuncMap = { {"+", [](long long x, long long y){return x + y;}}, {"-", [](long long x, long long y){return x - y;}}, {"*", [](long long x, long long y){return x * y;}}, {"/", [](long long x, long long y){return x / y;}} }; for (auto& str : tokens) { if (opFuncMap.count(str))//判断操作符是否在opFuncMap { long long right = st.top(); st.pop(); long long left = st.top(); st.pop(); st.push(opFuncMap[str](left, right)); } else//操作数 { st.push(stoi(str)); } } return st.top(); } };
使用function包装器解决模板效率地下，实例化多份的问题
在一开始我们引入包装器时，提出了传不同的类型，要实例化三份，导致模板效率低下，现在我不再传直接函数指针、lambda……了，相反用包装器将其包装起来就解决此问题了：
#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; }
此时会发现只实例化了一份，count的地址始终是一样的，所以静态成员变量自然在累加。由此可见，包装器统一了类型。
function包装器的意义
- 将可调用对象的类型进行统一，便于我们对其进行统一化管理。
- 包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。
2、bind包装器
bind包装器的引入
看如下的代码：
#include<map> #include <functional> int f(int a, int b) { return a + b; } struct Functor { public: int operator() (int a, int b) { return a + b; } }; class Plus { public: Plus(int x = 2) :_x(x) {} int plusi(int a, int b) { return (a + b) * _x; } private: int _x; };非静态成员函数是有隐含的this指针的，所以在包装plusi函数的时候得多传一个参数（共3个），这是我们前面讲过的，而Functor和f仅需传2个参数即可：
int main() { // 函数名(函数指针) std::function<int(int, int)> func1 = f; cout << func1(1, 2) << endl;//3 // 仿函数 std::function<int(int, int)> func2 = Functor(); cout << func2(10, 20) << endl;//30 //类的非静态成员函数 std::function<double(Plus, int, int)> func3 = &Plus::plusi;//非静态成员函数必须加&，静态可不加 cout << func3(Plus(), 100, 200) << endl;//300.22 }假设我现在利用包装器建立字符串和对应函数的映射关系，并放到map容器里头，此时就会出现问题了：成员函数会有三个参数，而我map容器里的value位置仅允许传两个参数，导致参数无法匹配：
为了解决此问题，就需要用到我们下面的bind包装器。
bind包装器的概念
bind包装器概念：
- std::bind函数定义在头文件<functional>中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序和个数调整等操作。
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的一般形式：
auto newCallable = bind(callable,arg_list);解释说明：
- callable：需要包装的可调用对象。
- newCallable：本身是一个可调用对象
- arg_list：是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。
arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。
bind包装器绑定调整参数个数
绑定普通函数：
int Plus(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); cout << func1(1, 2) << endl;//3 }
- 绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是placeholders::_1和placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_2。此时绑定后生成的新的可调用对象的传参方式，和原来没有绑定的可调用对象是一样的，也可以称之为无意义的绑定趴
调整参数个数：
- 我可以把Plus函数的第二个参数固定绑定为20，只需要把参数列表的placeholders::_2设置为20即可，此时调用绑定后新生成的可调用对象时就只需要传入一个参数。如下：
int Plus(int a, int b) { return a + b; } int main() { //表示绑定函数 plus 的第2个参数为20 std::function<int(int)> func2 = std::bind(Plus, placeholders::_1, 20); cout << func2(5) << endl;//25 }绑定成员函数：
class Plus { public: Plus(int x = 2) :_x(x) {} int plusi(int a, int b) { return (a + b) * _x; } private: int _x; }; int main() { //未绑定，需要传3个参数 std::function<int(Plus, int, int)> func1 = &Plus::plusi; cout << func1(Plus(), 100, 200) << endl;//600 //绑定后，仅需传2个参数 std::function<int(int, int)> func2 = std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2); cout << func2(100, 200) << endl;//3000 //绑定指定参数，func3的第一个参数已被指定，仅需传1个参数 std::function<int(int)> func3 = std::bind(&Plus::plusi, Plus(10), 15, placeholders::_1); cout << func3(25) << endl;//400 return 0; }
- 通过func1、func2、func3的对比，很明显我func1是直接包装的，需要传3个参数（其中一个隐含的this指针），func2绑定调整过后，也就是把Plus()绑定了，调用时会固定帮我们传一个匿名对象给this指针，也就只需要传2个参数；我func3是绑定调整指定参数，func3的第一个参数已被指定为15，只需要传1个参数即可。
下面来解决一开始引入bind时出现参数个数不匹配的问题：
解决此问题，我们只需要使用绑定来调整参数个数即可：
int f(int a, int b) { return a + b; } struct Functor { public: int operator() (int a, int b) { return a + b; } }; class Plus { public: Plus(int x = 2) :_x(x) {} int plusi(int a, int b) { return (a + b) * _x; } private: int _x; }; int main() { map<string, std::function<int(int, int)>> opFuncMap = { { "普通函数指针", f }, { "函数对象", Functor()}, { "成员函数指针", std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2)} }; cout << opFuncMap["普通函数指针"](1, 2) << endl;//3 cout << opFuncMap["函数对象"](10, 20) << endl;//30 cout << opFuncMap["成员函数指针"](100, 200) << endl;//3000 return 0; }此时成员函数指针绑定调整过后，也就是把Plus()绑定了，调用时会固定帮我们传一个匿名对象给this指针，也就只需要传2个参数，就不会出现参数不匹配的情况了。
bind包装器绑定调整参数顺序
对于如下的Sub类的成员函数sub，第一个参数为隐含的this指针，如果想要在调用Sub成员函数时不用对象进行调用this指针，我们可以将sub成员函数的第一个参数固定绑定为一个Sub对象。比如：
class Sub { public: int sub(int a, int b) { return a - b; } }; int main() { std::function<int(int, int)> func1 = std::bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2); cout << func1(1, 2) << endl;//-1 return 0; }
- 此时只需要传用于两个相减的参数了，因为在调用时会固定帮我们传一个匿名对象给this指针。
下面如果我想交换两个相减参数的顺序，只需要在绑定时把placeholders::_1和placeholders::_2的位置交换一下即可：
class Sub { public: int sub(int a, int b) { return a - b; } }; int main() { //调整顺序 std::function<int(int, int)> func2 = std::bind(&Sub::sub, Sub(), placeholders::_2, placeholders::_1); cout << func2(1, 2) << endl;//1 return 0; }此时实参1传给_2，也就是第二个参数，实参2传给_1，也就是第一个参数，2-1=1。
bind包装器的意义
- 将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。
- 可以对函数参数的顺序进行灵活调整。