C++11——variadic template

例1：

//例1：

void print()//递归出口
{
	cout << "递归出口" << endl;
}

template<typename T, typename... Types>//版本1
void print(const T&firstArg, const Types&...args)
{
	cout << firstArg << endl;
	print(args...);
}

template<typename... Types>//版本2
void print(const Types&...args)
{
	cout << "test" << endl;
	print(args...);
}
//注意：版本1比版本2更特化，所以版本2永远不会被调用
int main()
{

	print(7.5, "hello", bitset<16>(377), 42);

	system("pause");
	return 0;
}

例2：简单实现形参为initializer_list的max函数

//例2
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
_my_max_element(_ForwardIterator _first, _ForwardIterator _last,_Compare cmp)
{
	if (_first == _last)return _first;
	_ForwardIterator _result = _first;
	while (++_first != _last)
	{
		if (cmp(_result, _first))
			_result = _first;
	}
	return _result;
}

//自定义比较函数functor
class cmp
{
public:
	template<typename _Iterator1, typename _Iterator2>
	bool 
	operator()(_Iterator1 _it1, _Iterator2 _it2)const
	{
		return *_it1 < *_it2;
	}
};


template<typename _ForwardIterator>
inline _ForwardIterator
my_max_element(_ForwardIterator _first, _ForwardIterator _last)
{
	return _my_max_element(_first, _last, cmp());
}

template<typename _T>
inline _T my_max(initializer_list<_T>_l)
{
	return *my_max_element(_l.begin(), _l.end());
}
int main()
{
	cout << my_max({ 1,2,5,3,7,9,5 }) << endl;
	cout << max({ 1,2,5,3,7,9,5 }) << endl;//这是标准库中的版本
	system("pause");
	return 0;
}

例3：利用可变参数模板实现例2的效果

int maximum(int n)//只有1个参数时调用这个版本，是递归的出口
{
	return n;
}
template<typename ...Args>
int maximum(int n, Args... args)//至少2个参数才可以调用这个版本
{
	return max(n, maximum(args...));
}
int main()
{
	cout << maximum(1, 2, 5, 3, 7, 9, 5) << endl;
	system("pause");
	return 0;
}

例4：使用可变参数模板简单实现tuple

对于上图的代码，要改一个错误的地方，见下图的黄标处。

这张图看明白后发现真的是经典！

#include<iostream>
#include<vector>
#include<bitset>
#include<algorithm>
#include<set>
using namespace std;

template<typename...Values>class my_tuple;//版本1
template<>class my_tuple<> {};//版本1对应的全特化，作为递归的出口


template<typename Head, typename...Tail>//比版本1更特化的版本2
class my_tuple<Head, Tail...> :private my_tuple<Tail...>
{
public:
	//default constructor
	my_tuple() {}
	//constructor
	my_tuple(Head v, Tail... vtail) :m_head(v), my_tuple<Tail...>(vtail...) {}//初始化列表中调用了基类的constructor

	Head head() { return m_head; }
	my_tuple<Tail...>& tail() { return *this; }//返回的是直接基类的对象（派生类对象赋给一个基类引用）
protected:
	Head m_head;

};


int main()
{
	my_tuple<int, float, string>t(41, 6.3, "nico");
	cout << t.head() << endl;//41
	cout << t.tail().head() << endl;//6.3
	cout << t.tail().tail().head() << endl;//nico

	system("pause");
	return 0;
}

当然，上面这个例子是利用了继承的方式创建，其实也可以用嵌套（复合）的方式：