0
点赞
收藏
分享

微信扫一扫

C++ 包装器深剖

Gaaidou 2022-10-22 阅读 48
c++包装器函数指针仿函数实例化云平台云计算


目录

  • ​​传统艺能😎​​
  • ​​概念🤔​​
  • ​​类型统一🤔​​
  • ​​意义🤔​​
  • ​​bind 包装器😎​​
  • ​​bind 绑定固定参数😎​​
  • ​​调整传参顺序😎​​

传统艺能😎


C++ 包装器深剖_c++

概念🤔

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

包装器定义式：

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

其中的 是被包装的可调用对象的返回值类型，

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

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()
{
  //包装函数指针、函数名
  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;
  return 0;
}

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

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

类型统一🤔

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

  return f(x);
}

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

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

double f(double i)
{
  return i / 2;
}
struct Functor
{
  double operator()(double d)
  {
    return d / 3;
  }
};
int main()
{
  //函数指针
  cout << func(f, 11.11) << endl;

  //仿函数
  cout << func(Functor(), 11.11) << endl;

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

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

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

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

int main()
{
  //函数名
  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;
  return 0;
}

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

求解逆的步骤如下：

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

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

class Solution {
public:
  int evalRPN(vector<string>& tokens) {
    stack<int> st;
    for (const auto& 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:
  int evalRPN(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 (const auto& 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。

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

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

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

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

调整传参顺序😎

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

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

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

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

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

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

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

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


举报

相关推荐

C++模板深剖

c++模板语法类模板实例化OpenStack云计算

C++ 异常机制深剖

c++异常安全抛出异常sqlLinux系统/运维

C++ lambda 表达式深剖

lambda 表达式c++11仿函数lambda表达式赋值虚拟化云计算

C++ 11 | 包装器

svn

深剖 C++ 继承——十分钟手撕C++

c++开发语言派生类子类父类编程语言

三部曲深剖C++类与对象——中篇

c++类与对象构造函数编译器成员变量虚拟化云计算

Linux 权限管理深剖

linux服务器权限文件类型普通用户Linux系统/运维

深剖 Linux 进程地址空间

linuxbash进程地址空间虚拟地址虚拟化云计算

Linux 进程控制深剖

linux服务器进程子进程父进程虚拟化云计算

C++函数对象包装器function类详解

c++算法开发语言
0 条评论