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次调用;从而达到节省多次实例化的时间开销和空间开销