C++11变长模板解析（深入理解C++11）

参考自：深入理解C++11

变长模版：

变长函数和变长的模版参数

变长函数：

double
sum(int n, ...)//求n个double数据之和
{
double
sum = 0;
va_list
args;//接受输入数据的数据结构，需声明stdarg.h，
va_start(args,
n); //初始化数据
while (n>0)
{
sum += va_arg(args,
double); //将args中的数据一一取出，每隔sizeof(double)取一次数，再求和
--n;
}
va_end(args);
return
sum;
}

变长的模版参数：

pair<int,
double> PairNum
std::tuple<>double,
char, int, std::string> collections

变长模版：模版参数包和函数参数包

模版参数包：

变长类模版：

template<typename...Elements>class
tuple;

在标识符Elements之前使用了省略号…来表示该参数是变长的。Elements被称作三一个“模版参数包”。这样tuple 就可以接受任意多个参数作为模版参数。其实例化的tuple模版类：

tuple<int ,char,double>

编译器则可以将多个模版参数打包成大哥的模版参数包Elements,即Elements在进行模版推导的时候，就是一个包含int,char,double三种类型类型集合。

也可以声明非类型的模版参数包，如：

template<int …A>classNonTypeVariadicTemplate{}

NonTypeVariadicTemplate<1,2,3>ntvt;

就是定义了个：

template<int，int,int>class NonTypeVariadicTemplate{}

NonTypeVariadicTemplate<1,2,3>ntvt;

一个模版参数包在模版推导的时候会被认为是模版的单个参数。为了使用模版参数包，我们总是需要将其解包（Unpack）。在C++11中，这通常需要通过一个名为包扩展的表达式来完成：

template <typename …A>classTemplate:private B<A…>{};

式中的表达式A…就是一个包扩展。这样参数包会在包扩展的位置展开为多个参数。如：

template<typename
T1, typename
T2>class
B{};
template<typename ...A>class
Template :private
B<A...>{};
Template<X,
Y> xy;

这样，我们为类模版声明了一个参数包A,而使用参数包A…则是在Template的私有基类B<A…>中，那么最后一个表达式就声明了一个基类为B<X,Y>的模版类Template<X,Y>的对象xy。基类B总是接受两个参数，如果参数包的参数个数大于两个，我们在进行模版推导的时候就会发生错误。

事实上，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>,则我们需要构造tuple<int,char,float>,然后将设置head为double型。依次构造tuple<char,float>和设置int head,tuple<float>，char head,tuple<> float head;这样就完成了实例化。

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; };

函数参数包：

template<typename...T>
void f(T...args);

T为变长模板参数，args则是对应于这些变长类型的数据，即函数参数包。C++11中，要去函数参数包必须唯一而且是函数的最后一个参数（模板参数包没有这样的要求）。

void
Printf(const char *s)
{
while (*s)
{
if (*s ==
'%'&&*++s !=
'%')
{
throw runtime_error("invalid formatstring: 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("extraarguments provided to Printf");
}

int main()
{
Printf("hello %s\n",
std::string("world"));
return 0;
}

相比于变长函数，变长函数模板不会丢弃参数的类型信息。因此重载的cout总是可以将具有类型的变量正确的打印出来。这就是变长模板函数强于变长函数的地方。

C++11定义了七种参数包可以展开的位置：

1. 表达式

2. 初始化列表

3. 基类描述列表

4. 类成员初始化列表

5. 模板参数列表

6. 通用属性列表

7. Lambda函数的捕捉列表

如果我们生命Arg为参数包，那么可以使用Arg&&…这样的包扩展表达式，其解包后等价于Arg1&&,…,Argn&&(Arg1为包中的第一个参数，Argn为包中的第n个参数)。

1. template<typename…A>classT:private B<A>…{};

2. template<typename…A>classT:private B<A…>{};

同样实例化T<X,Y>;

1解包后为classT<X,Y>：private B<X>,private B<Y>{};

2解包后为classT<X,Y>：private B<X, Y>{};

操作符sizeof…,其作用是计算参数包中的参数个数。