c++11——可变参数模板

1. 可变参数模板函数

template<class... T>
void f(T... args){
cout << sizeof...(args) << endl; //sizeof...(args) 取得可变参数的个数
}
f();
f(1, 2);
f(1, 2.3, "hello");

#include<iostream>
using namespace std;
//递归终止函数
void print(){
cout << "empty" << endl;
}
//展开函数
template<class T, class... Args>
void print(T head, Args... rest){
cout << "parameter = " << head << endl;
print(rest...);
}

int main(){
print(1,2,3,4);
return 0;
}
//当调用print(1,2,3,4)时，先后调用print(2,3,4), print(3,4),print(4),最终调用print()终止。
如果递归终止函数为
template<typename T>
void print(T a){
cout << a << endl;
}则函数调用到 print(4)就终止。

//相当于递归终止函数
template<typename I = 0, typename Tuple>
typename std::enable_if<I==std::tuple_size<Tuple>::value>::type printtp(Tuple t){

}
//相当于展开函数
template<typename I = 0, typename Tuple>
typename std::enable_if<I < std::tuple_size<Tuple>::value>::type printtp(Tuple t){
std::cout << std::get<I>(t) << std::endl;   //打印出元组中的第i个
printtp<I+1>(t);
}

template<typename... Args>
void print(Args... args){
printtp(std::make_tuple(args...);
}

template<typename T>
void printarg(T a){
cout << a << endl;
}

template<class...Args>
void expand(Args... args){
int arr[] = {(printarg(args), 0)...};
//或者改进为 std::initializer_list<int>{(printarg(args), 0)...};
}
//{(printarg(args), 0)...}会被展开为{(printarg(arg1), 0), (printarg(arg2), 0), (printarg(arg3), 0)}
expand(1,2,3,"hello");

template<typename... Args>
void print(Args... args){
int arr[] = { (args, 0)... }; //具名的args...（或者匿名的...) 代表所有的可变参数集合，可以将args和...分开，此时args表示...中每一个参数。
}

template<typename... Args>
void expand(Args... args){
std::initializer_list<int>{([&]{cout << args << endl;}(), 0)...};
}

2. 可变参数模板类

template<class... Types>
class tuple;
这个可变参数模板类可以携带任意类型任意个数的模板参数
std::tuple<int> tp1 = std::make_tuple(1);
std::tuple<int, double> tp2 = std::make_tuple(1,2.4);
std::tuple<> tp;

template<typename... Args>  //前向声明
struct Sum;

template<typename First, typename... Rest>  //类的定义
struct Sum<First, Rest...>{
enum {value = Sum<First>::value + Sum<Rest...>::value};
};

template<typename Last> //递归终止类，模板参数不一定为1个，可能为0个或者2个
struct Sum<Last>{
enum{value = sizeof(Last)};
};
这个Sum类的作用是在编译期计算出参数包中参数类型的size之和。

或者可通过std::integral_constant来修改一下：
template<typename... Args>      //前置声明
struct Sum;

template<typename First, typename... Rest>  //递归定义
struct Sum<First, Rest...>: std::integral_constant<int, std::integral_constant<int, sizeof(First)>::value + Sum<Rest...>::value{
};

template<typename Last> //递归终止
struct Sum<Last>: std::integral_constant<int, sizeof(Last)>{
};

//整型序列的定义
template<int...>
struct IndexSeq{};

//继承方式，开始展开参数包
template<int N, int ... Indexes>
struct MakeIndexes: MakeIndexes<N -1, N -1, Indexes...>{};

//模板特化，终止展开参数包的条件
template<int... Indexes>
struct MakeIndexes<0, Indexes...>{
typedef IndexSeq<Indexes...> type;
};
int main(){
using T = MakeIndexes<3>::type;  //输出为 struct IndexSeq<0,1,2>
cout << typeid(T).name() << endl;
return 0;
};

//MakeIndexes如果不通过继承递归方式生成，可以通过using来实现。
template<int N, int ...Indexes>
struct MakeIndexes{
using type = MakeIndexes<N-1,N-1,Indexes>::type;
};

template<int...Indexes>
struct MakeIndexes<0, ...Indexes>{
using type =  IndexSeq<Indexes...>;
};

可以使用上述的IndexSeq来展开并打印可变模板参数，比如：
template<int ...Indexes, typename ...Args>
void print_helper(IndexSeq<Indexes...>, std::tuple<Args...>&& tup){
print(std::get<Indexes>(tup)...);
}

template<typename ...Args>
void print(Args... args){
print_helper(typename MakeIndexes<sizeof...(args)>::type(), std::make_tuple(args...));
}