C++ 包装器深剖

目录

传统艺能😎

小编是双非本科大一菜鸟不赘述，欢迎米娜桑来指点江山哦（QQ：1319365055）

🎉🎉非科班转码社区诚邀您入驻🎉🎉
小伙伴们，打码路上一路向北，彼岸之前皆是疾苦
一个人的单打独斗不如一群人的砥砺前行
这是我和梦想合伙人组建的社区，诚邀各位有志之士的加入！！
社区用户好文均加精（“标兵”文章字数2000+加精，“达人”文章字数1500+加精）
直达： 社区链接点我

概念🤔

所谓的包装器其实就是 function 包装器，也称为适配器，他的功能就是对可调用对象进行包装，包装器底层原理的本质其实就是类模板

包装器定义式：

template <class T> function;// undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

其中的

      R
     
     
      e
     
     
      t
     
    
   
  
  
   \color{red} {Ret }
  
 
Ret 是被包装的可调用对象的返回值类型，

 
  
   
    
     
      A
     
     
      r
     
     
      g
     
     
      s
     
     
      .
     
     
      .
     
     
      .
     
    
   
  
  
   \color{red} {Args...}
  
 
Args... 是被包装的可调用对象的形参类型

function包装器可以对可调用对象进行包装，包括函数指针、函数名、仿函数（函数对象）、lambda表达式、类的成员函数：

intf(int a,int b){return a + b;}structFunctor{
public:intoperator()(int a,int b){return a + b;}};
class Plus
{
public:staticintplusi(int a,int b){return a + b;}doubleplusd(double a,double b){return a + b;}};intmain(){//包装函数指针、函数名
    function<int(int,int)> func1 = f;
    cout <<func1(1,2)<< endl;//包装仿函数（函数对象）
    function<int(int,int)> func2 =Functor();
    cout <<func2(1,2)<< endl;//包装lambda表达式
    function<int(int,int)> func3 =[](int a,int b){return a + b;};
    cout <<func3(1,2)<< endl;//类的静态成员函数//function<int(int, int)> func4 = Plus::plusi;
    function<int(int,int)> func4 =&Plus::plusi;//&可省略
    cout <<func4(1,2)<< endl;//类的非静态成员函数
    function<double(Plus,double,double)> func5 =&Plus::plusd;//&不可省略
    cout <<func5(Plus(),1.1,2.2)<< endl;return0;}

如我上面所注：
取静态成员函数的地址可以不用 &，但取非静态成员函数的地址必须使用 &；包装非静态的成员函数时还需要注意，非静态成员函数第一个参数是隐藏 this 指针，因此在包装时需要指明第一个形参的类型为类的类型

包装时指明返回值类型和各形参类型，然后将可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了，

类型统一🤔

template<class F, class T>
T func(F f, T x){staticint a =0;
    cout <<"a: "<<++a << endl;
    cout <<"a: "<<&a << endl;returnf(x);}

对于一个函数模板，传入该函数模板的第一个参数可以是任意的可调用对象，比如函数指针、仿函数、lambda 表达式等；类模板中定义了静态变量 a，并在每次调用时将对象 a 的值和地址进行了打印，可判断多次调用时调用的是否是同一个函数

在传入第二个参数类型相同的情况下，如果传入的可调用对象的类型是不同的，那么在编译阶段该函数模板就会被实例化多次：

doublef(double i){return i /2;}structFunctor{doubleoperator()(double d){return d /3;}};intmain(){//函数指针
    cout <<func(f,11.11)<< endl;//仿函数
    cout <<func(Functor(),11.11)<< endl;//lambda表达式
    cout <<func([](double d)->double{return d /4;},11.11)<< endl;return0;

由于函数指针、仿函数、lambda 表达式是不同的类型，因此 func 函数会被实例化出三份，三次调用 func 函数所打印 a 的地址也是不同的

但实际上根本没必要实例化出三份 func 函数，因为这三个可调用对象的返回值和形参类型都是相同的，这时就可以用包装器分别对三个可调用对象进行包装，然后再用这三个包装后的可调用对象来调用 func 函数，这时就只会实例化出一份 func 函数

根本原因就是因为包装后，这三个可调用对象都是相同的 function 类型，因此最终只会实例化出一份 func 函数，该函数的第一个模板参数的类型就是 function 类型的

intmain(){//函数名
    function<double(double)> func1 = func;
    cout <<func(func1,11.11)<< endl;//函数对象
    function<double(double)> func2 =Functor();
    cout <<func(func2,11.11)<< endl;//lambda表达式
    function<double(double)> func3 =[](double d)->double{return d /4;};
    cout <<func(func3,11.11)<< endl;return0;}

这时三次调用 func 函数打印 a 的地址就是相同的，并且 a 在三次调用后会被累加到 3，表示这一个 func 函数被调用了三次：

求解逆

     波兰表达式
    
   
  
  
   \color{red} {波兰表达式}
  
 
波兰表达式的步骤如下：

定义一个栈，依次遍历所给字符串，如果遍历到的字符串是数字则直接入栈。
如果遍历到的字符串是 ±*/，则从栈顶抛出两个数字进行对应的运算，并将运算后得到的结果压入栈中。
所给字符串遍历完毕后，栈顶的数字就是逆波兰表达式计算结果

按照以前的思路，本题应该对不同的情况进行分类讨论，典型的 switch-case 模型，如下：

class Solution {
public:intevalRPN(vector<string>& tokens){
        stack<int> st;for(constauto& str : tokens){int left, right;if(str =="+"|| str =="-"|| str =="*"|| str =="/"){
                right = st.top();
                st.pop();
                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;default:break;}}else{
                st.push(stoi(str));}}return st.top();}};

过程粗暴且比较冗杂，如果继续加入余数，幂运算，对数运算等要求，我们的 switch-case 情况会更加复杂缠绕，所以我们这里可以利用包装器对齐进行优化，思路就是：建立各个运算符与其对应函数之间的映射关系，当执行某一运算时就可以直接通过运算符找到对应的函数进行执行；当运算类型增加时，就只需要建立新增运算符与其对应函数之间的映射关系即可:

class Solution {
public:intevalRPN(vector<string>& tokens){
        stack<int> st;
        unordered_map<string, function<int(int,int)>> opMap ={{"+",[](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;}}};for(constauto& str : tokens){int left, right;if(str =="+"|| str =="-"|| str =="*"|| str =="/"){
                right = st.top();
                st.pop();
                left = st.top();
                st.pop();
                st.push(opMap[str](left, right));}else{
                st.push(stoi(str));}}return st.top();}};

需要注意的是，这里建立的是运算符与function类型之间的映射关系，因此无论是函数指针、仿函数还是lambda表达式都可以在包装后与对应的运算符进行绑定

意义🤔

1. 将可调用对象的类型进行统一，便于对其进行统一化管理
2. 包装后明确了可调用对象的返回值和形参类型，更加方便使用

bind 包装器😎

bind 是一种函数包装器，也叫做适配器。它可以接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表，C++ 中的 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 的参数的“位置”。数值 n 表示生成的可调用对象中参数的位置，比如 _1 为 newCallable 第一个参数，_2 为第二个参数，以此类推。

此外，除了用 auto 接收包装后的可调用对象，也可以用 function 类型指明返回值和形参类型后接收包装后的可调用对象

bind 绑定固定参数😎

如果绑定时第一个参数传入的是函数指针，但后续传入要绑定的参数列表依次是 placeholders::_1和 placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_2。

此时绑定后生成的可调用对象的传参方式，和原来没绑定的可调用对象是一样的，所以下面这种就是一个无意义的绑定：

intPlus(int a,int b){return a + b;}intmain(){//无意义绑定
    function<int(int,int)> func =bind(Plus, placeholders::_1, placeholders::_2);
    cout <<func(1,2)<< endl;//3return0;}

此时我们把可以在绑定时将参数列表的 placeholders::_2 设置为 10，意味着 Plus 的第二个参数固定绑定成立 10，调用绑定后的函数时就只需要传入一个参数，它会将该参数与 10 的结果一起返回，这就是所谓的参数固定绑定：

intPlus(int a,int b){return a + b;}intmain(){//绑定固定参数
    function<int(int)> func =bind(Plus, placeholders::_1,10);
    cout <<func(2)<< endl;//12return0;}

调整传参顺序😎

对于 Sub 类中的 sub 函数，因为 sub 的第一个参数是隐藏的 this 指针，如果想要在调用 sub 时不用对象进行调用，那么可以将 sub 的第一个参数固定绑定为一个 Sub 对象：

class Sub
{
public:intsub(int a,int b){return a - b;}};intmain(){//绑定固定参数
    function<int(int,int)> func =bind(&Sub::sub,Sub(), placeholders::_1, placeholders::_2);
    cout <<func(1,2)<< endl;//-1return0;}

此时调用对象时就只需要传入用于相减的两个参数，因为在调用时会固定帮我们传入一个匿名对象给 this 指针。

如果想要将 sub 的两个参数顺序交换，那么直接在绑定时将 placeholders::_1 和 placeholders::_2 的位置交换一下就行了：

class Sub
{
public:intsub(int a,int b){return a - b;}};intmain(){//调整传参顺序
    function<int(int,int)> func =bind(&Sub::sub,Sub(), placeholders::_2, placeholders::_1);
    cout <<func(1,2)<< endl;//1return0;}

原理就是后续调用新生成的对象时，第一个参数会传给 placeholders::_1，第二个参数会传给 placeholders::_2，因此可以在绑定时通过控制 placeholders::_n 的位置，来控制第 n 个参数的传递位置

其意义就是：将一个函数的某些参数绑定为固定的值，在调用时可以不用传递某些参数，并且可以对参数顺序进行灵活调整

aqa 芭蕾 eqe 亏内，代表着开心代表着快乐，ok 了家人们