C++11的可变参数模板

本文主要是介绍C++11的可变参数模板，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

可变参数模板函数

一个可变参数模板函数的定义如下：

template <class... T>

void f(T... args)

{

　　cout<<sizeof...(args)<<endl; //打印变参的个数

}

f();　　　　　　　 //0　

f(1,2);　　　　　　//2

f(1,2.5,"");　　　　//3

1.递归函数方式展开参数包

通过递归函数展开参数包，需要提供一个参数包展开的函数和一个递归终止函数，递归终止函数正是用来终止递归，来看下面的例子。

 1 #include <iostream>
 2 using namespace std;
 3 
 4 void print()
 5 {
 6     cout << "empty" << endl;
 7 }
 8 
 9 template <class T,class ...Args>
10 void print(T head,Args... rest)
11 {
12     cout << "parameter "<<head << endl;        //打印变参的个数
13     print(rest...);
14 }
15 
16 int main()
17 {
18     print(1, 2, 3, 4);
19     return 0;
20 }

输出结果为：

2.逗号表达式和初始化列表方式展开参数包

递归函数展开参数包是一种标准做法，也比较好理解，但也有一个缺点，就是必须有一个重载的递归终止函数，即必须有一个同名的终止函数来终止递归，这样会感觉稍有不便。其实还有一种方法可以不通过递归方式来展开参数包。比如：

 1 #include <iostream>
 2 using namespace std;
 3 
 4 template <class T>
 5 void printarg(T t)
 6 {
 7     cout << t << endl;
 8 }
 9 
10 template <class ...Args>
11 void expand(Args... args)
12 {
13     int arr[] = { (printarg(args),0)... };
14 }
15 
16 int main()
17 {
18     expand(1, 2, 3, 4);
19     return 0;
20 }

也可以打印1,2,3,4四个数字。

可变参数模板类

可变参数模板类是一个带可变模板参数的模板类，第1章中介绍的std::tuple就是一个可变模板类，它的定义如下：

template<class... Types>

class tuple;

这个可变参数模板类可以携带任意类型任意个数的模板参数：

std::tuple<int> tp1=std::make_tuple(1);

std::tuple<int, double> tp2=std::std::make_tuple(1, 2.5);

std::tuple<int, double,string> tp2=std::std::make_tuple(1, 2.5,"test");

可变参数模板的模板参数个数可以为0，所以下面的定义也是合法的：

std::tuple<> tp;

1.模板递归和特化方式展开参数包

可变参数模板类的展开一般需要定义2~3个类，包括类声明和特化的模板类。如下方式定义了一个基本的可变参数模板类：

template<typename... Args>structSum;

template<typename First, typename... Rest>

struct Sum<First, Rest...>

{

　　enum { value = Sum<First>::value +Sum<Rest...>::value);

}

template<typename Last>struct Sum<Last>

{

　　enum { value = sizeof （Last）};

}

这个sum类的作用是在编译期计算出参数包中参数类型的size之和，通过sum<int, double, short>::value就可以获取这3个类型的size之和为14。这是一个简单的通过可变参数模板类计算的例子，可以看到一个基本的可变参数模板应用类由三部分组成，第一部分是：

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>struct Sum<Last>

{

　　enum { value = sizeof （Last）};

}

上面的这种3段式的定义也可以改为两段式，去掉前向声明：

template<typename First, typename... Rest>

struct sum

{

　　enum { value = Sum<First>::vlue+Sum< Rest...>::value);

};

template<typename Last>

{

　　enum { value = sizeof(Last); };

}

2.继承方式展开参数包

除了通过模板递归和模板特化的方式展开，还有另外一种方式：通过继承和特化的方式展开。下面的例子就是通过继承的方式去展开参数包

 1 //整数序列的定义
 2 template<int...>
 3 struct IndexSeq{};
 4 
 5 //继承方式，开始展开参数包
 6 template<int N, int... Indexes>
 7 struct MakeIndexes : MakeIndexes<N-1, N-1, Indexes...> {};
 8 
 9 //模板特化，终止展开参数包的条件
10 template<int... Indexes>
11 struct MakeIndexes<0, Indexes...>
12 {
13     typedef IndexSeq<Indexes...> type;          
14 };
15 
16 int main()
17 {
18     using T = MakeIndexes<3>::type;
19     cout<<typeid(T).name()<<endl;
20     return 0;
21 }

最终输出的类型是struct IndexSeq<0, 1, 2>

这篇关于C++11的可变参数模板的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

C/C++教程