参考自：深入理解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…,其作用是计算参数包中的参数个数。
