关于模板偏特化，模板递归，及Loki之Typelist和一些感悟

一直以来，在大多数情况下，递归被看做是低效率的表现，从学习编程开始，就一直被教导，不用或至少少用递归。但在模板编程中，递归和模板偏特化联合，起了相当大的作用。可以说，没有递归，在很大程度上，模板编程便无从谈起。给我感觉是，在模板编程中，递归是唯一有效的手段……

一个很简单的例子如下：

template <unsigned long N>
struct binary
{
  static unsigned const value
        = binary<N/10>::value*2 + N%10;
};

template < >
struct binary<0>
{
  static unsigned const value = 0;
};

该例子在编译期将无符号的十进制数字转换为等价的二进制数字。第一个template是递归主体，第二个template是递归的边界条件。从模板技术的角度来看，第二个是对一个模板的特化。在任一次迭代中，两个模板并不会同时被进行，编译器会根据当前条件选择最合适的一个模板。对编译器来说，这里并不存在什么递归之类，编译器所看到的只是：一个模板需要被实例化，而实例化之后，编译器又看到一个模板需要被实例化……于是有了递归。

可以想象一下，其实我们所需要的不过是最后的那一串二进制数字，但为了在“编译期”得到这数字，编译器额外的产生了很多以后永远不会用到的模板实例。从某一角度讲，我很质疑递归在模板编程的大量使用是否得当……

话题远了些。



最近看Loki库，和《C++设计新思维》。Loki中，对模板的运用有点让人晕眩的感觉。Loki中大量使用了模板偏特化，模板递归。这在Typelist中表现尤为突出。

Typelist本身只是一个关于型别的List而已，虽然自身的用处并没有我想象中的大，但Typelist几乎构成了整个Loki的基础。对Type的使用能到这个程度，我觉得完全登峰造极了。



Loki中，对Typelist的定义如下：

/* define keyword */
	#define typelist	typename

	/* NullType */
	struct NullType;

	/* decal of Typelist */
	template < typename _fir_type, typename _snd_type >
	struct Typelist
	{
		typedef	_fir_type		Head;
		typedef	_snd_type		Tail;
	};

	/* define a serial of typelist */
	#define	TYPELIST_1(type1)											Typelist< type1, NullType >
	#define	TYPELIST_2(type1,type2)								Typelist< type1, TYPELIST_1(type2) >
	#define	TYPELIST_3(type1,type2,type3)					Typelist< type1, TYPELIST_2(type2,type3) >
	#define	TYPELIST_4(type1,type2,type3,type4)		Typelist< type1, TYPELIST_3(type2,type3,type4) >
	// ......

	/* example : define of concrete typelist */
	typedef TYPELIST_3( char, signed char, unsigned char )		CharList;

	typedef TYPELIST_4( signed char, short int, int, long int )		SignedIntegrals;
	/* there can be more */

说得更确切点，这是我自己的定义。在Loki中，并没有：

#define typelist	typename

而我个人觉得，如果一个template的形参中全是typename T，或者class T，不免有点让人混乱。但如果定义一个typelist关键字，用以在某些适当的地方取代typename 或者class，那样的话会更醒目。

例如：

/* search in typelist */
	// search _type in _list
	template < typelist _list, typename _type >	struct IndexOf;

IndexOf，在typelist中搜索某type，其第一个参数是一个typelist，第二个参数是一个type，用所定义的关键字typelist取代typename ，来更清晰的表达IndexOf的语义。

不过使用#define来定义typelist，其实不太好的，没有想到更好的办法。typename并不是一个type，不能使用typedef。



这让我想到不久前，我看到C#中有这样的代码：（原谅我还没来得及学习C#……）

（http://blog.zhaojie.me/2010/06/more-why-java-sucks-and-csharp-rocks-1-reddit-and-property.html）

// C#
users.Sort(u => u.Age);

该代码表示：“有一个User数组，我们要根据它的年龄进行排序”……无疑这样的表达更体现出了程序员的用意，即是体现了what而不是how。而在C++中，我们应该怎么写？我们可以写个方法，可以重载一个操作符，可以……而所有这些（至少是我所能想到的），都没有C#的这一句更能表达程序员的意图。

于是我想，是不是可以在C++自己创建一个运算符，比如=>来与C#类似的完成任务。答案是否定的，C++中不能新建运算符，其实好像缩语的语言都不能，但还是感到有些遗憾。比如也许我能将>>符号重载写出：users>>u.Age这样的代码，但怎么都觉得很奇怪……

语言都有语言的缺陷。C++总让我觉得是一门超大巨炮，什么都可以搞定。但在使用这门巨炮之前，得为这门巨炮铺一公里的代码……其实我本想完成的事情不过是排个序或者复制个数据罢了……

但用惯C++后，用其他什么都觉得很奇怪。比如我学python时，发现没有指针，没有typedef，我觉得相当不可思议……



说远了。再回来。

关于所#define 的TYPELIST_1，在Loki中一直写到了TYPELIST_50。用户在外部可以使用TYPELIST_50（...）来定义自己的一个有50个型别的typelist，但这样似乎暴露了我们内部的实现……（但在模板中，什么不是暴露的呢……），是不是有办法给出一个统一的接口，用户定义自己的typelist时可以不用写出TYPELIST_50这样神奇的代码，而只用给出他要typelist的型别即可。

Loki中有MakeTypelist，如下：

////////////////////////////////////////////////////////////////////////////////
// class template MakeTypelist
// Takes a number of arguments equal to its numeric suffix
// The arguments are type names.
// MakeTypelist<T1, T2, ...>::Result
// returns a typelist that is of T1, T2, ...
////////////////////////////////////////////////////////////////////////////////

        template
        <
            typename T1  = NullType, typename T2  = NullType, typename T3  = NullType,
            typename T4  = NullType, typename T5  = NullType, typename T6  = NullType,
            typename T7  = NullType, typename T8  = NullType, typename T9  = NullType,
            typename T10 = NullType, typename T11 = NullType, typename T12 = NullType,
            typename T13 = NullType, typename T14 = NullType, typename T15 = NullType,
            typename T16 = NullType, typename T17 = NullType, typename T18 = NullType
        > 
        struct MakeTypelist
        {
        private:
            typedef typename MakeTypelist
            <
                T2 , T3 , T4 , 
                T5 , T6 , T7 , 
                T8 , T9 , T10, 
                T11, T12, T13,
                T14, T15, T16, 
                T17, T18
            >
            ::Result TailResult;

        public:
            typedef Typelist<T1, TailResult> Result;
        };

        template<>
        struct MakeTypelist
        <
            NullType, NullType, NullType, 
            NullType, NullType, NullType, 
            NullType, NullType, NullType, 
            NullType, NullType, NullType,
            NullType, NullType, NullType,
            NullType, NullType, NullType
        >{
            typedef NullType Result;
        };

用户定义用：MakeTypelist<T1, T2, ...>::Result。看起来很复杂，其实是：递归+偏特化。第一个template在递归，而第二个是以偏特化的形式作为递归的终结条件的。最终当18个type都是NullType时，停止递归，也就完成了定义Typelist的任务。

不太明白的是，为什么只有18个Type?难道作者只允许定义18个？

在网上有看到另一种形式的MakeTypelist，是定义了一个50个Type的list，并使用即将介绍到的EraseAll来删除除最后一个NullType之外的其他NullType。不过觉得在Typelist这个递归+偏特化的场所显得不太合事宜……



接下来就是一系列的只在编译期进行call的模板函数。几乎全是递归+偏特化的机制：

	/* Length of typelist */
	template < typelist _list >	struct Length;

	template < > struct Length< NullType >
	{
		enum { value = 0 };
	};
	template < typename _fir, typename _snd >
	struct Length < Typelist< _fir, _snd > >
	{
		enum { value = 1 + Length< _snd >::value };
	};

	/* Index of Typelist */
	// must be declared as this
	template < typelist _list, unsigned int index >	struct TypeAt;

	template < typename Head, typename Tail >
	struct TypeAt< Typelist< Head, Tail >, 0 >
	{
		typedef Head	Result;
	};

	template < typename Head, typename Tail, unsigned int index >
	struct TypeAt< Typelist< Head, Tail >, index >
	{
		typedef typename TypeAt< Tail, index-1 >::Result	Result;
	};

/* search in typelist */
	// search _type in _list
	template < typelist _list, typename _type >	struct IndexOf;
	// if the list is NullType, then the index is -1
	// that means there is no _type in the _list
	template < typename _type >
	struct IndexOf< NullType, _type >
	{
		enum { index = -1 };
	};

	// if the head of _list is _type(what we are search for)
	// then the index is 0
	// that means we found _type just here
	template < typename Tail, typename _type >
	struct IndexOf< Typelist< _type, Tail >, _type >
	{
		enum { index = 0 };
	};

	// the main process
	template < typename Head, typename Tail, typename _type >
	struct IndexOf< Typelist< Head, Tail >, _type >
	{
	private:
		enum { temp = IndexOf< Tail, _type >::index };

	public:
		enum { index = (temp == -1)? (-1) : (temp+1) };
	};

	/* append: */
	// _type may be a typelist or typename
	template < typelist _list, typename _type >	struct Append;

	// when typelist and _type are both null
	template < >
	struct	Append < NullType, NullType >
	{
		typedef NullType	ResultList;
	};

	// when the typelist is null but _type is non null
	template < typename _type >
	struct	Append < NullType, _type >
	{
		typedef TYPELIST_1(_type)	ResultList;
	};

	// if the _type is a typelist and the typelist is null
	template < typename Head, typename Tail >
	struct	Append < NullType, Typelist< Head, Tail > >
	{
		typedef Typelist< Head, Tail >	ResultList;
	};

	// else
	template < typename Head, typename Tail, typename _type >
	struct	Append < Typelist< Head, Tail >, _type >
	{
		typedef Typelist< Head, Append< Tail, _type > >
			ResultList;
	};

/* remove */
	/// remove the first of _type
	template < typelist _list, typename _type >	struct Erase;

	// when they are null
	template < typename _type >
	struct	Erase < NullType, _type >
	{
		typedef NullType	ResultList;
	};

	// when _type is the head
	template < typename Tail, typename _type >
	struct	Erase < Typelist<_type, Tail>, _type >
	{
		typedef Tail	ResultList;
	};

	// else
	template < typename Head, typename Tail, typename _type >
	struct	Erase < Typelist<Head, Tail>, _type >
	{
		typedef Typelist< Head, typelist Erase<Tail, _type>::ResultList >
			ResultList;
	};

	/// remove all _type in typelist
	template < typelist _list, typename _type >	struct EraseAll;

	template < typename _type >
	struct	EraseAll < NullType, _type >
	{
		typedef NullType	ResultList;
	};

	template < typename Tail, typename _type >
	struct	EraseAll < Typelist<_type, Tail>, _type >
	{
		typedef typelist Erase<Tail, _type>::ResultList
			ResultList;
	};

	template < typename Head, typename Tail, typename _type >
	struct	EraseAll < Typelist<Head, Tail>, _type >
	{
		typedef Typelist< Head, typelist EraseAll<Tail, _type>::ResultList >
			ResultList;
	};

	/* remove the duplicates */
	template < typelist _list >	struct DoDuplicates;

	// null
	template < >
	struct DoDuplicates < NullType >
	{
		typedef NullType	ResultList;
	};

	// main process
	// this is a very interesting func
	template < typename Head, typename Tail >
	struct DoDuplicates < Typelist<Head,Tail> >
	{
	private:
		typedef typelist DoDuplicates< Tail >::ResultList		_list_1;
		// in the tail(maybe a list), erase head(must be a _type anytime)
		typedef typelist Erase< _list_1, Head >::ResultList		_list_2;

	public:
		typedef Typelist< Head, _list_2 >						ResultList;
	};

	/* replace */
	/// replace signed
	template < typelist _list, typename _replaced_type, typename _replace_type >
	struct	Replace;

	// null
	template < typename _replaced_type, typename _replace_type >
	struct	Replace < NullType, _replaced_type, _replace_type >
	{
		typedef NullType	ResultList;
	};

	template <  typename Tail, 
							typename _replaced_type, 
							typename _replace_type >
	struct	Replace <  Typelist< _replaced_type,Tail >, 
										_replaced_type, 
										_replace_type >
	{
		typedef Typelist< _replace_type, Tail >		ResultList;
	};

	template <  typename Head,
							typename Tail,
							typename _replaced_type,
							typename _replace_type >
	struct	Replace <  Typelist< Head, Tail >, 
										_replaced_type, 
										_replace_type >
	{
		typedef
			Typelist< Head,
					  typelist Replace< Tail, 
															_replaced_type, 
															_replace_type >::ResultList >
			ResultList;
	};

	/// replace all
	template < typelist _list, typename _replaced_type, typename _replace_type >
	struct	ReplaceAll;

	// null
	template < typename _replaced_type, typename _replace_type >
	struct	ReplaceAll < NullType, _replaced_type, _replace_type >
	{
		typedef NullType	ResultList;
	};

	template <  typename Tail, 
							typename _replaced_type, 
							typename _replace_type >
	struct	ReplaceAll < Typelist< _replaced_type,Tail >, 
											_replaced_type, 
											_replace_type >
	{
		// typedef Typelist< _replace_type, Tail >		ResultList;
		typedef 
			Typelist< _replace_type, 
					  typelist ReplaceAll< Tail,
																 _replaced_type, 
																 _replace_type >::ResultList >
			ResultList;
	};

	template <  typename Head,
							typename Tail,
							typename _replaced_type,
							typename _replace_type >
	struct	ReplaceAll < Typelist< Head, Tail >, 
											_replaced_type, 
											_replace_type >
	{
		typedef
			Typelist< Head,
					  typelist ReplaceAll<  Tail, 
																	_replaced_type, 
																	_replace_type >::ResultList >
			ResultList;
	};

本没有什么话说的。但在实际的Coding中，出了不少问题。template<...>中是参数，在其下的struct或函数中出现的参数必须出现在template的参数列表中。



想说一下的是模板片特化；我的理解是，模板偏特化即是显式地给出模板的参数，使之仅对某种情况适用。例如：

/* remove */
	/// remove the first of _type
	template < typelist _list, typename _type >	struct Erase;

	// when they are null
	template < typename _type >
	struct	Erase < NullType, _type >
	{
		typedef NullType	ResultList;
	};

其中，struct Erase < NullType, _type >即是显式得给出typelist _list为NullType，从而实现偏特化。当编译器在进行模板实例化时，就会从所有的目标中（包括泛化和偏特化版本），选取最合适的那一个进行实例化。

泛化版本和偏特化版本在模板实例化中扮演的角色可以看做是：泛化是递归体，偏特化是边界条件（即是非递归体，一个确定体）



所有这上边的，都是对型别进行操作。所作的基本是基础性的工作。下面要说的是，用所有这上边的，来做点实际能有点作用的，实际可以在运行期留下足迹的东西。



进行class的模板级Create操作：

/*------------------------------------*/
	/*------------- To Create Class-------*/
	/*------------------------------------*/
	// must be template <class>
	template	< typelist _list, template <typename> class Unit >
	class	GenScatterHierarchy;

	// do nothing for null type
	template < template <typename> class Unit >
	class	GenScatterHierarchy < NullType, Unit >
	{
	};

	// atomic type
	template < typename AtomicType,  template <typename> class Unit >
	class	GenScatterHierarchy : public Unit< AtomicType >
	{
	};

	// typelist to unit
	// _type_1,_type_2 mustn't be type, maybe typelist
	template < typename _type_1, 
						 typename _type_2, 
						 template< typename > class Unit >
	class	GenScatterHierarchy < Typelist <_type_1, _type_2>, Unit >
				: public	GenScatterHierarchy< _type_1, Unit >
				, public	GenScatterHierarchy< _type_2, Unit >
	{
	};

Class产生在编译期，可能被运行期使用。产生的方式是通过继承，和对继承的实例化。这实际上也是一个模板递归的过程。在这里，atomic type是边界。

既然产生出了class，那么剩下的事就是从这么一堆class中选择正确的class了。由于涉及到，可能在typelist中存在重复的type，因此Loki中作出了一个Helper。如下：

/*-------------------------------------*/
	/*------ To get the right Class--------*/
	/*-------------------------------------*/
	// Field helper -- to index the type
	template < typelist _list, template <class> class Unit >
	Unit <typename _list::Head>&	FieldHelper ( GenScatterHierarchy < _list, Unit >& obj,
												  Int2Type< 0 > )
	{
		GenScatterHierarchy < typename _list::Head, Unit >&	leftBase  = obj;
		return leftBase;
	}

	template < int anyInt, typelist _list, template <class> class Unit >
	Unit <typename TypeAt<_list, anyInt>::Result>&	FieldHelper( GenScatterHierarchy < _list, Unit >& obj,
																 Int2Type < anyInt > )
	{
		GenScatterHierarchy < typename _list::Tail, Unit >&	rightBase = obj;
		return	FieldHelper( rightBase, Int2Type <anyInt-1>() );
	}

	// Field
	template < typelist _list, int anyInt, template <class> class Unit >
	Unit <typename TypeAt<_list, anyInt>::Result>&	Field ( GenScatterHierarchy < _list, Unit >& obj )
	{
		return FieldHelper( obj, Int2Type < anyInt >() );
	}

在这里使用了Int2Type，通过Int2Type来构成另一个参数，Int2Type< 0 >是边界条件。



Typelist让我想起了《数据结构》中的广义表。二者太像了。都是分为头尾，都是递归的广泛使用。



最后是我的测试用例。其中使用了Typeinfo的外覆类。

#include <iostream>
#include "TypeList.h"
#include "TestTypeList.h"
#include "TypeInfo.h"

using namespace TL;
using namespace std;

int main()
{
	// int idx = 1;
	typedef	TYPELIST_4( int, int, string, char )	mytype;
	typedef	GenScatterHierarchy < mytype, Holder >	WidgetInfo;

	WidgetInfo obj;
	// type_info	typeinfo;		// cann't be used as this

	Field<mytype,1>(obj).value = 8;

	int x = Field<mytype,1>(obj).value;

// TEST1: use std::type_info
	// typeinfo = typeid ( Field< mytype, 1 > (obj) );
	// cout<<typeid ( Field< mytype, 1 > (obj) ).name()<<endl;

// TEST2: use type_info wrapper
	TypeInfo	typeinfo( typeid(Field<mytype,2>(obj)) );
	cout<<typeinfo.name()<<endl;
}