C++11中的变长模板的示例详解
作者:Shawn-Summer
1.C99中的变长函数
宏函数可以实现变长:就是采用C99中的变长宏__VA_ARGS__,如下所示为C99代码:
#include<stdio.h> #define LOG(...){\ fprintf(stderr,"%s: Line %d:\t",__FILE__,__LINE__);\ fprintf(stderr,__VA_ARGS__);\ fprintf(stderr,"\n");\ } int main() { int x=3; LOG("x=%d",x);//D:\study\c++\c++11\__VA_ARGS__.cpp: Line 10: x=3 }
普通函数也可以实现变长
#include<stdio.h> #include<stdarg.h> double SumOfFloat(int count,...) { va_list ap; double sum=0; va_start(ap,count);//使得ap初始化为参数列表的handle for(int i=0;i<count;i++) sum+=va_arg(ap,double);//每次读取sizeof(double)的字节 va_end(ap); return sum; } int main() { printf("%f\n",SumOfFloat(3,1.2f,3.4,5.6));//10.200000 }
注意看上面代码中,SumOfFloat中的第一个参数count,这就意味著,你必须告诉函数它的参数的具体个数,这就不太方便,例如SumOfFloat(3,1.2f,3.4,5.6)中的第一个参数3。
2.C++11中的变长函数
C++11实现上面功能的一种方法是:使用initializer_list作为函数形参
#include<iostream> #include<initializer_list> using namespace std; double SumOfFloat(const initializer_list<double>& l) { double sum=0; for(auto &val:l) sum+=val; return sum; } int main() { printf("%f\n",SumOfFloat({1.2f,3.4,5.6}));//10.200000 }
这种思路感觉有点投机取巧,不太好
另一种方法是使用变长模板
#include<iostream> template<typename... T>double SumOfFloat(T...);//模板函数声明 template<typename ...Args>//递归定义 double SumOfFloat(double a,Args... args) { return a+SumOfFloat(args...); } double SumOfFloat(double a){return a;}//边界条件 int main() { printf("%f\n",SumOfFloat(1.2f,3.4,5.6));//10.200000 }
先不对上述代码做解释,只要知道<typename... T>中的T叫做模板参数包,它是类型的,是一种特殊的类型,它可以被推导为多个类型的pack。即SumOfFloat(1.2f,3.4,5.6)会将T推导为double,double,double的一种pack类型。
除此之外,必须知道这种设计必须是递归定义的。
3.详解变长模板
首先讲一个前置概念:SFINAE.
3.1 更一般的SFINAE规则
在C++98中,我们就有SFINAE法则:Substitution failure is not an error
即匹配失败不算失败,在C++中就是,即使模板展开失败,也不会报错
struct Test { typedef int FOO; }; template<typename T> void foo(typename T::FOO){} template<typename T> void foo(T){} int main() { foo<Test>(10); foo<int>(10); }
上面代码在C++98中也可以通过编译,上面foo(typename T::FOO)中typename显式的表示,T::FOO是一个类型,在foo<int>(10);中,编译器会尝试用 第一个模板函数来匹配它,但是会发现int::FOO错误,但是编译器不会报错,这就是SFINAE
在C++11中对SFINAE规则做了放松,
template<int I> struct A {}; char xxx(int); char xxx(float); template<typename T>A<sizeof(xxx((T)0))> f(T){} int main() { f(1); }
有一些C++98编译器会对上式报错,这是因为它们认为模板参数过于复杂,即这里的sizeof(xxx((T)0)),不过现在的编译器都狠优秀,它们可以完成这种表达式的推导,C++11的标准是:只要表达式中没有出现外部于表达式本身的元素,编译器都可以完成推导
3.2 模板参数包的概念
接下来的内容会有一定难度。
我们知道,在C++98中模板参数有3种:类型的,非类型的,模板类型的。
template<typename T,int i,template<typename> class A>中T就是类型的,i是非类型的,A是模板类型的。
在C++11中,我们为了支持变长的模板,我们加入一种新的模板参数:模板参数包。
所以在C++11中模板参数有4种:类型的,非类型的,模板类型的和模板参数包。
而模板参数包又可以细分为3种:类型的模板参数包,非类型的模板参数包,模板类型的模板参数包。
模板参数包是一种pack,下面我们从模板推导角度来解释这种pack:
1.(类型的)模板参数包
template <typename T1,typename T2>class B{}; template <typename... A>class Template: private B<A...>{}; Template<X,Y> xy;
上面中,<typename...A>中A是 (类型的)模板参数包,它可以接收任意多个类型参数作为模板参数,具体来说,Template<X,Y>会将A推导为X和Y类型的pack。
B<A...>中A...是一种包扩展,它是模板参数包unpack的结果。由于A被推导为X和Y的pack,所以A...就被具体解释为X,Y,然后具体化为B<X,Y>。
如果我们使用Template<X,Y,Z> xyz就会引发推导错误,没有任何一个模板适配,这是因为此时A...被解释为3个类型:X,Y,Z,它无法和B匹配。
2.(非类型的)模板参数包
template<int i,long j,unsigned int k>class B{}; template<int ...A> struct Pack: private B<A...>{}; Pack<1,0,2> data;
<int ... A>中A是 (非类型的)模板参数包,它可以接收分离多个非类型参数作为模板参数,具体来说,Pack<1,0,2>会将A推导为整值1,0,2的pack,而B<A...>中A...是一种包扩展,由于A推导为整值1,0,2的pack,所以A...被具体解释为1,0,2,然后具体化为B<1,0,2>
3.(模板类型的)模板参数包
template <typename T> class A; template <typename T> class B; template<template<typename> class T1,template<typename> class T2> class C{}; template<template<typename> class ...T> struct Pack:private C<T...>{}; Pack<A,B> data;
<template<typename> class ...T>中T是 (模板类型的)模板参数包,它可以接收多个模板作为模板参数,具体来说,Pack<A,B>会将T推导为A和B的pack,而C<T...>中T...就是一种包扩展,由于T推导为A和B的pack,所以T...就被具体解释为A,B,然后具体化为C<A,B>
3.3 三个简单的例子
变长模板必须采用递归设计,下面是3个简单的例子,请仔细阅读。
1.(类型的)模板参数包的使用
下面给出C++11中tuple的简单实现,
template<typename... Elements> class tuple;//模板声明 template <typename Head,typename... Tail>//递归定义 class tuple<Head,Tail...>:private tuple<Tail...> { Head head; }; template<> class tuple<>{};//边界条件
同样也是递归定义,这种递归的设计就是变长模板最晦涩的地方。
当实例化tuple<double,int,char,float>类时,
第一次:Head被推导为double,Tail...被推导为int,char,float
第二次:Head被推导为int,Tail...被推导为char,float
第三次:Head被推导为char,Tail...被推导为float
第三次:Head被推导为float,Tail...被推导为空
最后由class tuple<>进行递归构造出模板
2.(非类型的)模板参数包的使用
#include<iostream> using namespace std; template<long... nums> struct Multiply;//模板声明 template<long first,long... last>//递归定义 struct Multiply<first,last...> { static const long val=first*Multiply<last...>::val; }; template <>//边界条件 struct Multiply<> { static const long val=1; }; int main() { cout<<Multiply<2,3,4,5>::val<<endl; cout<<Multiply<22,44,66,88,9>::val<<endl; }
上面这种编程方式,叫做模板元编程,他将乘法的计算放到模板推导过程中,就是把计算过程放在编译阶段,这样运行时就不需要计算了
3.(模板类型的)模板参数包的使用
template <typename T> class Module1{}; template <typename T> class Module2{}; template<typename I,template<typename>class ... B>struct Container;//模板声明 template<typename I,template<typename> class A,template<typename> class... B> struct Container<I,A,B...>//递归定义 { A<I> a; Container<I,B...> b; }; template<typename I> struct Container<I>{};//边界条件 int main() { Container<int,Module1,Module2> a; }
3.4 函数参数包
函数参数包是在写变长模板函数中的一个概念
函数参数包也是一种pack型变量,它也存在unpack,包扩展的概念。
void g(int,char,double); template<typename ... T> void f(T... args) { g(args...); } f(1,'c',1.2);
在<typename ... T>中的T是 (类型的)模板参数包 。
在f(T... args)中T...叫做 包扩展
在f(T... args)中的args是一种类型为T...的变量,它叫函数参数包
在g(args...)中的args...也是一种包扩展,它是将argsunpack后的产物
例如,这里f(1,'c',1.2)就会将T推导为int,char,double的pack,于是T...就被具体解释为int,char,double,然后args就是类型为T...的一种变量,args的值是1,'c',1.2的pack,则我们可以在f中调用g(args...)完成对args的unpack。
下面看一个,C++11中提案的prinf()函数的实现
#include<iostream> #include<stdexcept> using namespace std; void Printf(const char*s)//边界条件 { while(*s) { if(*s=='%' && *++s!='%')//确保`%%`不出现 throw runtime_error("invalid format string: missing arguments"); cout<<*s++; } } template<typename T,typename ...Args>//递归定义 void Printf(const char*s,T value,Args... args) { while(*s) { if(*s=='%' && *++s!='%')//确保`%%`不出现 { cout<<value; return Printf(++s,args...); } cout<<*s++; } throw runtime_error("extra arguments provided to Printf"); } int main() { Printf("hello %s\n",(string)"world"); }
变长模板的难点在于我们不知道参数的个数,我们必须采用递归定义,就像上面的Printf就是递归定义的,采用的是数学归纳法,可以细细品味一下上面那段代码。
3.5 包扩展的进阶
...符号可以放在意想不到的地方,例如:
template<typename... A> class T:private B<A>...{};//#1 template<typename... A> class T:private B<A...>{};//#2
对于实例化T<X,Y>,#1会被解释为
class T<X,Y> class T:private B<X>,private B<Y>{};
#2会被解释为
class T<X,Y> class T:private B<X,Y>{};
看一下下面这些例子:
#include<iostream> using namespace std; template<typename... T> void DummyWrapper(T... t){}; template<typename T> T pr(T t){ cout<<t; return t; } template<typename... A> void VTPrint(A... a) { DummyWrapper(pr(a)...); } int main() { VTPrint(1,", ",1.2,", abc\n"); }
上面这段代码,某些编译器(例如g++)的结果是逆序的:
, abc
1.2, 1
应该是,不同的编译器可能包扩展的顺序不太一样,有些的逆序的。
下面我们看一段晦涩难懂的代码
#include<iostream> #include<tuple> using namespace std; template<typename A,typename B> struct S { int a=1; }; template< template<typename...> class T, typename... TArgs, template<typename...> class U, typename... UArgs > struct S< T<TArgs...> , U<UArgs...> >{int a=2;}; int main() { S<int,float> p; S<tuple<int,char>,tuple<float>> s; //S<tuple,int,char,tuple,float> s;编译出错 cout<<s.a<<endl;//2 }
注意上面这段代码中,最终输出是2,奇怪的地方在于,S<tuple<int,char>,tuple<float>>如何匹配第二个模板呢?这种设计是约定俗称的,没有任何原因,记住上面这种巧妙的设计就行了。
3.6 sizeof...()的使用
sizeof...()其实狠简单的,它就是获得pack中的变量的个数,有些用的
#include<cassert> #include<iostream> using namespace std; template<typename... A> void Print(A... arg) { assert(false); } void Print(int a1,int a2,int a3,int a4,int a5,int a6) { cout<<a1<<", "<<a2<<", "<<a3<<", "<<a4<<", "<<a5<<", "<<a6<<endl; } template<class... A>int Vaargs(A... args) { int size=sizeof...(args);//或者sizeof...(A) switch (size) { case 0:Print(99,99,99,99,99,99); break; case 1:Print(99,99,args...,99,99,99); break; case 2:Print(99,99,args...,99,99); break; case 3:Print(args...,99,99,99); break; case 4:Print(99,args...,99); break; case 5:Print(99,args...); break; case 6:Print(args...); break; default: Print(0,0,0,0,0,0); } } int main() { Vaargs();//99, 99, 99, 99, 99, 99 Vaargs(1);//99, 99, 1, 99, 99, 99 Vaargs(1,2);//99, 99, 1, 2, 99, 99 Vaargs(1,2,3);//1, 2, 3, 99, 99, 99 Vaargs(1,2,3,4);//99, 1, 2, 3, 4, 99 Vaargs(1,2,3,4,5);//99, 1, 2, 3, 4, 5 Vaargs(1,2,3,4,5,6);//1, 2, 3, 4, 5, 6 Vaargs(1,2,3,4,5,6,7);//0, 0, 0, 0, 0, 0 }
3.7 变长模板和完美转发的配合
#include<iostream> using namespace std; struct A { A(){}; A(const A&a){cout<<"Copy Constructed "<<__func__<<endl;} A(A&& a){cout<<"Move Constructed "<<__func__<<endl;} }; struct B { B(){}; B(const B&b){cout<<"Copy Constructed "<<__func__<<endl;} B(B&& b){cout<<"Move Constructed "<<__func__<<endl;} }; template<typename... T> struct MultiTypes;//模板声明 template<typename T1,typename... T>//递归定义 struct MultiTypes<T1,T...>: public MultiTypes<T...> { T1 t1; MultiTypes<T1,T...>(T1 a,T... b):t1(a),MultiTypes<T...>(b...) { cout<<"MultiTypes<T1,T...>(T1 a,T... b)"<<endl; } }; template<> struct MultiTypes<>//边界条件 { MultiTypes<>(){cout<<"MultiTypes<>()"<<endl;} }; template<template<typename...> class VariadicType,typename... Args> VariadicType<Args...> Build(Args&& ... args) { return VariadicType<Args...>(std::forward<Args>(args)...); } int main() { A a; B b; Build<MultiTypes>(a,b); //等价于Build<MultiTypes,A,B>(a,b); }
MultiTypes<>()
MultiTypes<T1,T...>(T1 a,T... b)
MultiTypes<T1,T...>(T1 a,T... b)
没啥好说的,这就是完美转发,它根部就不调用移动构造和拷贝构造函数,完全都是靠引用传递的
以上就是C++11中的变长模板的示例详解的详细内容,更多关于C++11变长模板的资料请关注脚本之家其它相关文章!