c++可变参数模板解析

·  阅读 996
c++可变参数模板解析

前言

很高兴见到你。

我们知道,C++模板能力很强大,比起Java泛型这种语法糖来说,简直就是降维打击。而其中,可变参数模板,就是其中一个非常重要的特性。那什么是可变参数模板,以及为什么我们需要他?

首先我们考虑一个经典的场景:

我们需要编写一个函数,来打印变量信息。

比如:

int code = 1;
string msg = "success";
printMsg(code,msg); // 输出: 1,success
复制代码

而我们需要打印的参数信息是不确定的,也有可能是下面的情况:

float value = 0.8f;
printMsg(code,msg,"main"); // 输出: 1,success,main
printMsg(value,code); // 输出: 0.8,1
复制代码

printMsg的参数类型、数量都是不确定的,无论是普通模板、还是使用容器,都无法完成这个任务。而可变参数模板,可以非常完美完成这个任务。

可变参数模板,意为该模板的类型与数量都是不确定,能够接收任意的参数匹配,造就了其极高的灵活度。

认识可变模板参数

template<typename T,typename... Args>
void printMsg(T t, Args... args) {}
复制代码

上述代码为可变参数模板的例子。首先要了解一个概念:模板参数包,函数参数包

typename...表示一个模板参数包类型,在typename后跟了三个点 ,Args是一个模板参数包,他可以是0或多种类型的组合。Args...,表示将这个参数包展开,作为函数的形参,args也称为函数参数包

举个例子:

// T的类型是 int
// Args的类型是 int、float、string 组成的模板参数包
printMsg(1,2,0.8f,"success");

// 模板会被实例化为此函数原型
void printMsg(int,int,float,string);
复制代码

对于参数包,我们可以使用sizeof... 来获取该参数包中有多少个类型。如sizeof...(args); or sizeof...(Args);

那么,对于这个可变模板参数类型,我们要如何使用它呢?

使用可变模板参数

递归法

递归法利用的是类型匹配原理,将参数包中的参数,一个个给他分离出来。我们从一个实际的例子来理解他。假如我们要实现前言章节中的printMsg函数,那么他的实现代码如下:

template<typename T,typename ...Args>
void printMsg(const T& t, const Args&... args) {
    std::cout << t << ", ";
    printMsg(args...);
}

// 调用
printMsg(1,0.3f,"success");
复制代码

当我们调用printMsg(1,0.3f,"success")代码时,模板函数被实例化为:

template<int,float,string>
void printMsg(const int& t, const float& arg1, const string& arg2) {
    std::cout << t << ", ";
    printMsg(arg1, arg2); 
}
复制代码

代码中再次递归调用了printMsg,模板函数被实例化为:

template<float,string>
void printMsg( const float& arg1, const string& arg2) {
    std::cout << t << ", ";
    printMsg(arg2); 
}
复制代码

发现规律了吗?当我们不断递归调用printMsg时,参数报Args会被一层层解开,并将类型匹配到模板T上,从而将参数包Args中的参数逐一处理。

与此同时,我们也知道一个关键点:递归需要有终止条件。因此,我们需要在只剩下一个参数的时候将其终结:

template<typename T>
void printMsg(const T& t) {
    std::cout << t << std::endl;
}
复制代码

c++在匹配模板时,会优先匹配非可变参数模板,因此非可变参数模板则成为了递归的终止条件。这样我们就实现了一个函数,能够接受任意数量、任意类型(支持<<运算符)的参数。

特例化

递归法是最为常见的使用可变参数模板的方式。对于参数包来说,除了递归法,其次就为特例化。举个例子,还是我们上面的printMsg函数:

template<>
void printMsg(const int& errorCode,const float& strength,const double& value) {
    std::cout << "errorCode:" << errorCode << " strength:" << strength << " value:" << value << std::endl;
}

printMsg(1,0.8f,0.8);
复制代码

针对<int,float,double>类型的模板做了一个特例化,则在我们调用此类型的模板时,会优先匹配特例化。这也是一种处理可变模板参数的方式。

除此之外,还有很多对于可变模板参数的神奇用法,进一步提高他的灵活性。

包拓展

这里包,指的是函数参数包以及可变模板参数包。前面的例子中已经存在两个包拓展,但更多的是属于可变参数模板的语法层面,所以并没有展开说。比如上面我们提到的代码:

template<typename T,typename ...Args>
void printMsg(const T& t, const Args&... args) {
    std::cout << t << ", ";
    printMsg(args...);
}

printMsg(1,0.8f,0.8);
复制代码

这里有两个包拓展:

  1. 函数的形参,在Args& 之后跟了三个点,表示将Args参数包展开,例子中展开后的函数原型是void printMsg(const int&,const float&,const double&);
  2. 第二处展开是在递归调用时,将函数参数包形参展开args...,例子中展开后为printMsg(0.8f,0.8);

在涉及到函数调用、函数声明时,都需要用到上面这两个包拓展语法。但我们会发现并没有什么可以操作的空间,他更多就是一个可变模板函数的固定语法。但除此之外,包拓展可以有一个更加神奇的操作。

还是上面的例子,但是这里我们需要对打印的数据进行一轮过滤,对int数据超过99、float数据超过0.9进行预警报告,其他数据不做处理。那么这个怎么处理呢?

理论上说,我们需要对每个参数包中的每个数据进行处理,那我们可以在递归中,判断T的类型,再根据不同的类型进行处理。这种方式是可行的,但c++提供了更加好用的另一种方式。看下面的代码:

template<typename T>
const T& filterParam(const T& t) { return t; }

template<>
const int& fileterParam(const int& t) {
    if (t > 99) { onWarnReport(); }
    return t;
}

template<>
const float& fileterParam(const float& t) {
    if (float > 0.9) { onWarnReport(); }
    return t;
}

template<typename... Args>
void printMsgPlug(const Args&... args) {
    printMsg(filterParam(args)...);  //关键代码
}

printMsgPlus(1,0,3f,1.8f);

复制代码

可以看到我们的关键代码在于printMsg(filterParam(args)...);这一行,他等价于printMsg(filterParam(1),filterParam(0.3f) ,filterParam(1.8f)); 三个小点移动到了函数调用的后面,即可以实现这样的效果。

这种方式的优点在于,他可以将过滤相关的逻辑,抽离到另外一个函数中去单独处理,利用模板的特性对数据进行统一或者单独处理。而且,使用typeId判断类型的方式并不总是可靠的,这种方式会更加稳定。

此外,针对双重过滤的方式,包拓展的解决方案也会更加优雅。假如,我们在打印数据之前,需要对数据进行一次转换,之后再对转换结果进行过滤判断是否需要预警报告。那么我们的伪代码可以是如下:

template<typename T>
T filterParam(const T& t) {
    T result = convertParam(t);
    if()...
    return result;
}

template<typename T>
T convertParam(const T& t) {...}

template<typename... Args>
void printMsgPlug(const Args&... args) {
    printMsg(filterParam(args)...);  //关键代码
}
复制代码

而如果使用递归结合typeid的方式,可能就需要更多个switch进行类型匹配嵌套解决,且其结果总是不可靠的。

最后,并不是所有可变模板函数,都能使用递归去解决问题。例如我们需要一个能够构建unique_ptr的函数,他的简化版可以是这样的:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&... args) {
    return std::unique_ptr<T>(new T(fileterParam(args)...));
}
复制代码

这个写法是不够完善的,但是方便我们理解。这个时候,如果我们需要对参数进行过滤,那么递归的方式,就无法在这里使用了,而必须使用包拓展。

完美转发

完美转发在可变模板中非常常见,他的作用在于保持原始的数据类型。参考我们上面的make_unique函数,在移除fileterParam函数之后,,我们希望,传给make_unique函数的数据,能够原封不动地,传递给T的构造函数。那么他的实现如下:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
复制代码
  1. Args&& 表示通用引用,他能接收左值引用,也可以接收右值引用。
  2. std::forward 表示保持参数的原始类型。因为我们知道,右值引用本身是左值,所以我们需要将其转为右值传递给构造函数。

这样,我们就能够原封不动地将数据传递给构造函数,而不修改数据类型。这部分类型属于右值与引用的范畴,这里不详细展开解析。

但是对于可变模板来说,这里有一个关键需要注意一下:通用引用的本身,是 引用类型。假如我们传递了一个int类型进来,那么转化之后就变成了int&。此时如果我们使用Args类型去做模板匹配,很容易发生匹配失败的问题,会提示int&无法匹配到int类型,需要多加注意一下。要解决这个问题也比较简单,将其引用类型移除即可。在c++11中,可以使用以下代码移除所有的修饰与引用,保持基础的数据类型:

template<typename T>
using remove_cvRef = typename std::remove_cv<typename std::remove_reference<T>::type>::type;

std::vector<decltype(remove_cvRef<T>)> v;
复制代码

在匹配模板的时候,可以使用decltype来获取移除后的类型进行匹配。

总结

可变参数模板在实际的使用中,更多还是结合完美转发来使用,实现对象的统一构造或者接口调用封装等。可变参数的存在,使得模板接口的灵活度提升了一个档次,如果你在实际开发中遇到类似的需求,不妨使用一下,会给你带来惊喜的。

全文到此,原创不易,觉得有帮助可以点赞收藏评论转发。 有任何想法欢迎评论区交流指正。 如需转载请评论区或私信沟通。 另外欢迎光临笔者的个人博客:传送门

分类:
Android
标签:
收藏成功!
已添加到「」, 点击更改