学步园

1 Typelists的索引式访问

template <class TList, unsigned int index> struct TypeAt;

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

typedef TYPELIST_4(signed char, short int, int, long int) SignedIntegrals;
 

int main()
{
	cout << (sizeof(TypeAt<SignedIntegrals, 2>::Result) == sizeof(int) ? "int" : "non-int") << endl;
}

越界访问的问题？

编译器会显示找不到 TypeAt<NullType, x> 特化版本的编译错误消息，其中 x 是指定的越界索引。也可对越界访问更加宽容即以 NullType 为传回之，取代编译错误消息。

template <class TList, unsigned int index,
typename DefaultType = NullType>
struct TypeAtNonStrict
{
	typedef DefaultType Result;
};

template <class Head, class Tail, typename DefaultType>
struct TypeAtNonStrict < Typelist<Head, Tail>, 0, DefaultType >
{
	typedef Head Result;
};

template <class Head, class Tail, unsigned int i, typename DefaultType>
struct TypeAtNonStrict < Typelist<Head, Tail>, i, DefaultType >
{
	typedef typename
	TypeAtNonStrict<Tail, i - 1, DefaultType>::Result Result;
};

2 查找 Typelists

template <class TList, class T> struct IndexOf;

template <class T>
struct IndexOf < NullType, T >
{
	enum { value = -1 };
};
template <class Tail, class T>
struct IndexOf < Typelist<T, Tail>, T >
{
	enum { value = 0 };
};
template <class Head, class Tail, class T>
struct IndexOf < Typelist<Head, Tail>, T >
{
private:
	enum { temp = IndexOf<Tail, T>::value };
public:
	enum { value = temp == -1 ? -1 : 1 + temp };
};
typedef TYPELIST_4(signed char, short int, int, long int) SignedIntegrals;
 
int main()
{
	cout << IndexOf<SignedIntegrals, short int>::value << endl;
}

3 附加元素至 Typelists

template <class TList, class T> struct Append;
template <> struct Append < NullType, NullType >
{
	typedef NullType Result;
};
template <class T> struct Append < NullType, T >
{
	typedef TYPELIST_1(T) Result;
};
template <class Head, class Tail>
struct Append < NullType, Typelist<Head, Tail> >
{
	typedef Typelist<Head, Tail> Result;
};
template <class Head, class Tail, class T>
struct Append < Typelist<Head, Tail>, T >
{
	typedef Typelist < Head, typename Append<Tail, T>::Result > Result;
};

4 移除 Typelist 中的某个元素

template <class TList, class T> struct Erase;
template <class T>
struct Erase < NullType, T >
{
	typedef NullType Result;
};
template <class T, class Tail>
struct Erase < Typelist<T, Tail>, T >
{
	typedef Tail Result;
};
template <class Head, class Tail, class T>
struct Erase < Typelist<Head, Tail>, T >
{
	typedef Typelist<Head, typename Erase<Tail, T>::Result> Result;
};

typedef TYPELIST_4(signed char, short int, int, long int) SignedIntegrals;
typedef Erase<SignedIntegrals, signed char>::Result non_signed_char;

int main()
{
	cout << (sizeof(TypeAt<non_signed_char, 0>::Result) == sizeof(unsigned char) ? "unsignedchar" : "non-unsignedchar") << endl;
}

另一项移除操作 EraseAll，它会移除 typelist 中某个型别的所有出现个体。

template <class TList, class T> struct EraseAll;
template <class T>
struct EraseAll < NullType, T >
{
	typedef NullType Result;
};
template <class T, class Tail>
struct EraseAll < Typelist<T, Tail>, T >
{
	// Go all the way down the list removing the type
	typedef typename EraseAll<Tail, T>::Result Result;
};
template <class Head, class Tail, class T>
struct EraseAll < Typelist<Head, Tail>, T >
{
	// Go all the way down the list removing the type
	typedef Typelist<Head, typename EraseAll<Tail, T>::Result> Result;
};
typedef TYPELIST_3(int, int, char) hasTwoInts;
typedef EraseAll<hasTwoInts, int>::Result non_int;

int main()
{
	cout << (sizeof(TypeAt<non_int, 0>::Result) == sizeof(char) ? "char" : "non-char") << endl;
}

5 移除重复的元素

template <class TList> struct NoDuplicates;
template <> struct NoDuplicates < NullType >
{
	typedef NullType Result;
};
template <class Head, class Tail>
struct NoDuplicates < Typelist<Head, Tail> >
{
private:
	typedef typename NoDuplicates<Tail>::Result L1;
	typedef typename Erase<L1, Head>::Result L2; // Erase 被实施与NoDuplicate 递归之后。这意味着我们将从 list之中移除的是一个“不再有任何重复个体”的 型别，所以最多只会有一个型别个体被移除。
public:
	typedef Typelist<Head, L2> Result;
};
typedef TYPELIST_3(int, int, char) hasTwoInts;
typedef NoDuplicates<hasTwoInts>::Result noDuplicates;

int main()
{
	cout << (sizeof(TypeAt<noDuplicates, 1>::Result) == sizeof(char) ? "char" : "nonchar") << endl;
}

6 取代 Typelist 中的某个元素

template <class TList, class T, class U> struct Replace; // 用 U 来替换 TList 中的 T 类型
template <class T, class U>
struct Replace < NullType, T, U >
{
	typedef NullType Result;
};
template <class T, class Tail, class U>
struct Replace < Typelist <T, Tail>, T, U >
{
	typedef Typelist<U, Tail> Result;
};
template <class Head, class Tail, class T, class U>
struct Replace < Typelist<Head, Tail>, T, U >
{
	typedef Typelist<Head, typename Replace<Tail, T, U>::Result> Result;
};
typedef TYPELIST_4(signed char, short int, int, long int) SignedIntegrals;
typedef Replace<SignedIntegrals, int, char>::Result replace_int;
int main()
{
	cout << (sizeof(TypeAt<replace_int, 2>::Result) == sizeof(char) ? "char" : "nonchar") << endl;
}

ReplaceAll 版本：

template <class TList, class T, class U> struct ReplaceAll; // 用 U 来替换 TList 中的所有 T 类型
template <class T, class U>
struct ReplaceAll < NullType, T, U >
{
	typedef NullType Result;
};
template <class T, class Tail, class U>
struct ReplaceAll < Typelist <T, Tail>, T, U >
{
	typedef Typelist<U, typename ReplaceAll<Tail, T, U>::Result> Result;
};
template <class Head, class Tail, class T, class U>
struct ReplaceAll < Typelist<Head, Tail>, T, U >
{
	typedef Typelist<Head, typename ReplaceAll<Tail, T, U>::Result> Result;
};
typedef TYPELIST_3(int, int, char) hasTwoInts;
typedef ReplaceAll<hasTwoInts, int, short int>::Result repInt;

int main()
{
	cout << (sizeof(TypeAt<repInt, 0>::Result) == sizeof(short int) ? "short int" : "non-shortint") << " "
		<< (sizeof(TypeAt<repInt, 1>::Result) == sizeof(short int) ? "short int" : "non-shortint") << endl;
}