C++ wrapper 关于包装器详细介绍-案例分析

C++wrapper 关于包装器详细介绍-案例分析

1. 为什么需要包装器

先来一个案例：一个进行向量运算的模板Vec_mul_TP，更具传入的函数对象使用不同的向量运算方式：向量积（外积）、点积（内积）和数量积
（1）分别定义了两个类Dot_mul（求解向量点积），和Vec_mul（求解向量积）
（2）还定义了两个函数dot_mul（求解向量点积），和num_mul（求解数量积）
（3）各个函数对象（Dot_mul, Vec_mul, num_mul, dot_mul）输入是两个向量，输出都是一个结果向量

#include <iostream>
#include <vector>
using namespace std;
template<class T,class U,typename F>
vector<T> Vec_multiply_TP(vector<T> t,vector<U> u,F f){//两个向量乘积模板：点积 | 向量积 | 数量积
  static int count;//同一个实例化模板对象被调用的次数
  count++;
  cout<<"count="<<count<<"; and the address is:"<<&count<<endl;
  return f(t,u);//向量的积：具体看函数传入的函数形式
}
template<class T>
class Dot_mul{//向量点积
  public:
    Dot_mul(){}//构造函数，以列表的形式初始化
    vector<T> operator()(vector<T> x,vector<T> y){
      T sum;
      for(int i=0;i<x.size();i++) sum+=x[i]*y[i];
      vector<T> vector_res;
      vector_res.push_back(sum);
      return vector_res;
    }
};
template<class T>
class Vec_mul{//向量积
  public:
    Vec_mul(){}
    vector<T> operator()(vector<T>x,vector<T>y){
      T i=x[1]*y[2]-x[2]*y[1];
      T j=x[2]*y[0]-x[0]*y[2];
      T k=x[0]*y[1]-x[1]*y[0];//向量积，即外积
      return vector<T>{i,j,k};
    }
};
template<typename T>
vector<T> num_mul(vector<T> x,vector<T> m){//向量数量积：m为向量是为了和模板Vec_multiply_TP参数兼容
  return vector<T>{x[0]*m[0],x[1]*m[0],x[2]*m[0]};//返回一个匿名向量
}
template<typename T>
vector<T> dot_mul(vector<T> x,vector<T>y){
  T sum;
  for(int i=0;i<x.size();i++) sum+=x[i]*y[i];
  return vector<T>{sum};//返回一个匿名向量
}
int main(){
  vector<double> x{2.0,2.0,2.0};
  vector<double> y{1.0,2.0,3.0};
  cout<<"向量x=";
  for(auto item:x)cout<<item<<" ";
  cout<<endl<<"向量y=";
  for(auto item:y)cout<<item<<" ";
  cout<<endl;
  cout<<"下面使用的是类Dot_mul进行向量点积运算*********************************************************"<<endl;
  double res_dot_class=Vec_multiply_TP( x,y,  Dot_mul<double>())[0];//调用点积类(为了保证Vec_multiply_TP模板返回的数据类型一致)
  cout<<"x 和 y向量的点积为："<<res_dot_class<<endl;
  cout<<"下面使用的是类Vec_mul进行向量积运算*********************************************************"<<endl;
  vector<double> res_vec_class=Vec_multiply_TP(x,y,Vec_mul<double>());//调用向量积类
  cout<<"x 和 y向量的外积为：";
  cout<<"(";
  for(auto item:res_vec_class) cout<<item<<" ";
  cout<<")"<<endl;
  cout<<"下面使用的是函数num_mul进行数量积运算*********************************************************"<<endl;
  // auto num_mul_double=num_mul<double>;
  vector<double> res_num_mul_func=Vec_multiply_TP( x,vector<double>()={10.0},num_mul<double>);
  cout<<"(";  
  for(auto item:res_num_mul_func) cout<<item<<" ";
  cout<<")"<<endl;
  cout<<"下面使用的是函数dot_mul进行向量点积运算*********************************************************"<<endl;
  double res_dot_num_func=Vec_multiply_TP(x,y,dot_mul<double>)[0];
  return 0;
}

运行结果：

我们发现模板中的静态变量count具有3个不同的地址，也就是说模板Vec_multiply_TP进行了3次实例化，浪费实践开销和内存开销，我们的目的是希望该模板只进行一次实例化，于是提出了包装器这个概念，用于节省系统开销

2. 什么是包装器？如何使用包装器？

#include <iostream>
#include <vector>
#include <functional>//导入包装器functionnal工具库
using namespace std;
template<class T,class U,typename F>
vector<T> Vec_multiply_TP(vector<T> t,vector<U> u,F f){//两个向量乘积模板：点积 | 向量积 | 数量积
  static int count;//同一个实例化模板对象被调用的次数
  count++;
  cout<<"count="<<count<<"; and the address is:"<<&count<<endl;
  return f(t,u);//向量的积：具体看函数传入的函数形式
}
template<class T>
class Dot_mul{//向量点积
  public:
    Dot_mul(){}//构造函数，以列表的形式初始化
    vector<T> operator()(vector<T> x,vector<T> y){
      T sum;
      for(int i=0;i<x.size();i++) sum+=x[i]*y[i];
      vector<T> vector_res;
      vector_res.push_back(sum);
      return vector_res;
    }
};
template<class T>
class Vec_mul{//向量积
  public:
    Vec_mul(){}
    vector<T> operator()(vector<T>x,vector<T>y){
      T i=x[1]*y[2]-x[2]*y[1];
      T j=x[2]*y[0]-x[0]*y[2];
      T k=x[0]*y[1]-x[1]*y[0];//向量积，即外积
      return vector<T>{i,j,k};
    }
};
template<typename T>
vector<T> num_mul(vector<T> x,vector<T> m){//向量数量积：m为向量是为了和模板Vec_multiply_TP参数兼容
  return vector<T>{x[0]*m[0],x[1]*m[0],x[2]*m[0]};//返回一个匿名向量
}
template<typename T>
vector<T> dot_mul(vector<T> x,vector<T>y){
  T sum;
  for(int i=0;i<x.size();i++) sum+=x[i]*y[i];
  return vector<T>{sum};//返回一个匿名向量
}
int main(){
  vector<double> x{2.0,2.0,2.0};
  vector<double> y{1.0,2.0,3.0};
  cout<<"向量x=";
  for(auto item:x)cout<<item<<" ";
  cout<<endl<<"向量y=";
  for(auto item:y)cout<<item<<" ";
  cout<<endl;
  //开始使用包装器function
  function<vector<double>(vector<double>,vector<double>)> ef1=Dot_mul<double>();
  function<vector<double>(vector<double>,vector<double>)> ef2=Vec_mul<double>();
  function<vector<double>(vector<double>,vector<double>)> ef3=num_mul<double>;
  function<vector<double>(vector<double>,vector<double>)> ef4=dot_mul<double>;
  //模板使用和结果输出
  cout<<"Dot_mul(ef1):**********************************"<<endl;
  auto res_ef1=Vec_multiply_TP(x,y,ef1);
  cout<<"[Dot_mul方法] x(2.0,2.0,2.0)和y(1.0,2.0,3.0)的点积为："<<res_ef1[0]<<endl;
  cout<<"Dot_mul(ef2):**********************************"<<endl;
  auto res_ef2=Vec_multiply_TP(x,y,ef2);
  cout<<"[Vec_mul方法] x(2.0,2.0,2.0)和y(1.0,2.0,3.0)的向量积为："<<res_ef2[0]<<" "<<res_ef2[1]<<" "<<res_ef2[2]<<endl;
  cout<<"num_mul(ef3):**********************************"<<endl;
  auto res_ef3=Vec_multiply_TP(x,vector<double>{10.0},ef3);
  cout<<"[num_mul方法] x(2.0,2.0,2.0)和10.0的数量积为："<<res_ef3[0]<<" "<<res_ef3[1]<<" "<<res_ef3[2]<<endl;
  cout<<"dot_mul(ef4):**********************************"<<endl;
  auto res_ef4=Vec_multiply_TP(x,y,ef4);
  cout<<"[dot_mul方法] x(2.0,2.0,2.0)和y(1.0,2.0,3.0)的点积为："<<res_ef4[0]<<endl;
  return 0;
}

结果：

可以理解为将各种函数对象进行强制转换统一起来，因此模板只进行1次实例化（因为模板Vec_multiply_TP的静态变量count地址都是一致的），4次调用；从而达到节省多次实例化的时间开销和空间开销