C++——TypeList && Repeat Macro

横向重复宏

repeat.h

#ifndef _REPEAT_H_Y00183482_
#define _REPEAT_H_Y00183482_

#define DEC1 0
#define DEC2 1
#define DEC3 2
#define DEC4 3
#define DEC5 4
#define DEC6 5
#define DEC7 6
#define DEC8 7
#define DEC9 8
#define DEC10 9
#define DEC11 10
#define DEC12 11
#define DEC13 12
#define DEC14 13
#define DEC15 14
#define DEC16 15
#define DEC17 16
#define DEC18 17
#define DEC19 18
#define DEC20 19
#define DEC21 20
#define DEC22 21
#define DEC23 22

#define ADD0 1
#define ADD1 2
#define ADD2 3
#define ADD3 4
#define ADD4 5
#define ADD5 6
#define ADD6 7
#define ADD7 8
#define ADD8 9
#define ADD9 10
#define ADD10 11
#define ADD11 12
#define ADD12 13
#define ADD13 14
#define ADD14 15
#define ADD15 16
#define ADD16 17
#define ADD17 18
#define ADD18 19
#define ADD19 20
#define ADD20 21
#define ADD21 22
#define ADD22 23
#define ADD23 24
#define ADD24 25

#define LINK(A,B) LINK_I(A,B)
#define LINK_I(A,B) A##B

#define REPEAT_0(N, F) F(N)
#define REPEAT_1(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_2(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_3(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_4(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_5(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_6(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_7(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_8(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_9(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_10(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_11(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_12(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_13(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_14(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_15(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_16(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_17(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_18(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_19(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)
#define REPEAT_20(N, F) LINK(REPEAT_, LINK(DEC,N))(LINK(DEC,N), F), F(N)

#define PARA_MATA(N) typename T##N = VOID
#define REAL_MATA(N) typename LINK(T, LINK(ADD,N))
#define DECLEAR_PARA(N) LINK(REPEAT_,N)(N,PARA_MATA)
#define DECLEAR_REAL(N) LINK(REPEAT_,N)(N,REAL_MATA)
#endif

 

typelist.h

 

#ifndef _TYPELIST_H_Y00183482_ 
#define _TYPELIST_H_Y00183482_
#include "repeat.h"
struct VOID;
/*****************************************************************
	$ : 
*****************************************************************/
template <typename HEAD, typename TAIL>
struct TypeList
{
	typedef HEAD Head;
	typedef TAIL Tail;
};
template <typename HEAD>
struct TypeList<HEAD, VOID>
{
	typedef HEAD Head;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <DECLEAR_PARA(20)> struct MakeType
{
private:
	typedef typename MakeType<DECLEAR_REAL(19)>::result TailResult;
public:
	typedef TypeList<T0,TailResult> result;
};
template<> struct MakeType<>
{
	typedef VOID result;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <typename TL> struct Length;
template <typename Head,typename Tail>
struct Length<TypeList<Head,Tail> >
{ 
	static const int value = (int)Length<Tail>::value + 1; 
};
template <> struct Length<VOID>
{
	static const int value = 0;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <typename TL,int Index> struct TypeAt;
template <typename Head,typename Tail,int Index> 
struct TypeAt<TypeList<Head,Tail>,Index>
{
	typedef typename TypeAt<Tail,Index-1>::type type;
};
template <typename Head,typename Tail>
struct TypeAt<TypeList<Head,Tail>,0>
{
	typedef Head type;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <typename TL,typename Val> struct IndexOf;
template <typename Head, typename Tail, typename Val>
struct IndexOf<TypeList<Head,Tail>,Val>
{
private:
	static const int peek = (int)IndexOf<Tail,Val>::value;
public:
	static const int value = -1 == peek ? -1 : peek+1;
};
template <typename Head,typename Tail>
struct IndexOf<TypeList<Head,Tail>,Head>
{
	static const int value = 0;
};
template <typename Val>
struct IndexOf<VOID,Val>
{
	static const int value = -1;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <typename TL,typename T> struct Append;
template <> struct Append<VOID,VOID>
{
	typedef VOID type;
};
template <typename T> struct Append<VOID,T>
{
	typedef TypeList<T,VOID> type;
};
template <typename Head,typename Tail> 
struct Append<VOID,TypeList<Head, Tail> >
{
	typedef TypeList<Head, Tail> type;
};
template <typename Head,typename Tail>
struct Append<TypeList<Head,Tail> , VOID>
{
	typedef TypeList<Head,Tail> type;
};
template <typename Head,typename Tail,typename T>
struct Append<TypeList<Head,Tail>,T>
{
	typedef TypeList<Head,typename Append<Tail,T>::type> type;
};
template <typename Head, typename Tail, typename Head1, typename Tail1>
struct Append<TypeList<Head, Tail>, TypeList<Head1, Tail1> >
{
	typedef TypeList<Head, 
		typename Append<Tail, TypeList<Head1, Tail1> >::type> type;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <typename TL,typename T> struct AddHead;
template <typename T> struct AddHead<VOID, T>
{
	typedef VOID type;
};
template <typename Head, typename Tail>
struct AddHead<TypeList<Head, Tail>, VOID>
{
	typedef TypeList<Head, Tail> type;
};
template <typename Head, typename Tail, typename T>
struct AddHead<TypeList<Head, Tail>, T>
{
	typedef TypeList<T, typename  AddHead<Tail,T>::type> type;
};
template <typename Head,typename Tail, typename Head1, typename Tail1>
struct AddHead<TypeList<Head, Tail>, TypeList<Head1, Tail1> >
{
	typedef TypeList<Head1, 
		typename AddHead<TypeList<Head, Tail>,Tail1>::type> type;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <typename TL,typename T> struct EraseAll;
template <typename Head,typename Tail>
struct EraseAll<TypeList<Head,Tail>,VOID>
{
	typedef TypeList<Head,Tail> type;
};
template <typename T> struct EraseAll<VOID,T>
{
	typedef VOID type;
};
template <typename Head,typename Tail>
struct EraseAll<TypeList<Head,Tail>,Head>
{
	typedef typename EraseAll<Tail,Head>::type type;
};
template <typename Head,typename Tail,typename T>
struct EraseAll<TypeList<Head,Tail>,T>
{
	typedef TypeList<Head,typename EraseAll<Tail,T>::type> type;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <typename TL,typename T> struct EraseOne;
template <typename T> struct EraseOne<VOID,T>
{
	typedef VOID type;
};
template <typename Head, typename Tail> 
struct EraseOne<TypeList<Head, Tail>, VOID>
{
	typedef TypeList<Head, Tail> type;
};
template <typename Head, typename Tail>
struct EraseOne<TypeList<Head, Tail>, Head>
{
	typedef Tail type;
};
template <typename Head, typename Tail, typename T>
struct EraseOne<TypeList<Head, Tail>, T>
{
	typedef TypeList<Head,typename EraseOne<Tail, T>::type> type;
};
/*****************************************************************
	$ : 
*****************************************************************/
template <typename TL> struct NoDuplicates;
template <> struct NoDuplicates<VOID>
{
	typedef VOID type;
};
template <typename Head, typename Tail> 
struct NoDuplicates<TypeList<Head, Tail> >
{
private:
	typedef typename NoDuplicates<Tail>::type midtype;
	typedef typename EraseOne<midtype, Head>::type realtail;
public:
	typedef TypeList<Head, realtail> type;
};
#endif

 

测试:main.cpp

#include <iostream>
using namespace std;
#include "typelist.h"

int main()
{
	cout<<"---------------MakeType test----------------------------------------"<<endl;
	cout<<typeid(MakeType<char,int,int,int,int,short,short,int,int,int,char>::result).name()<<endl;
	cout<<"---------------MakeType test----------------------------------------"<<endl;

	cout<<"---------------Length test--------------------------------------------"<<endl;
	cout<<Length<MakeType<char,int,int,int,int,short,short,int,int,int,char>::result>::value<<endl;
	cout<<Length<MakeType<>::result>::value<<endl;
	cout<<"---------------Length test--------------------------------------------"<<endl;
	
	cout<<"---------------TypeAt test-------------------------------------------"<<endl;
	cout<<typeid(TypeAt<MakeType<char,int,short,double>::result, 2>::type).name()<<endl;
	cout<<typeid(TypeAt<MakeType<char,int,short,double>::result, 0>::type).name()<<endl;
	cout<<typeid(TypeAt<MakeType<char,int,short,double>::result, 3>::type).name()<<endl;
	cout<<"---------------TypeAt test-------------------------------------------"<<endl;

	cout<<"---------------IndexOf test------------------------------------------"<<endl;
	cout<<IndexOf<MakeType<char,int,short,double>::result, double>::value<<endl;
	cout<<IndexOf<MakeType<char,int,short,double>::result, int>::value<<endl;
	cout<<IndexOf<MakeType<char,int,short,double>::result, short>::value<<endl;
	cout<<IndexOf<MakeType<char,int,short,double>::result, char>::value<<endl;
	cout<<"---------------IndexOf test------------------------------------------"<<endl;
	
	cout<<"---------------Append test------------------------------------------"<<endl;
	cout<<typeid(Append<MakeType<char,int,short>::result, double>::type).name()<<endl;
	cout<<typeid(Append<MakeType<char,int>::result,MakeType<float,short>::result>::type).name()<<endl;
	cout<<"---------------Append test------------------------------------------"<<endl;
	
	cout<<"---------------AddHead test-----------------------------------------"<<endl;
	cout<<typeid(AddHead<MakeType<int,char>::result,VOID>::type).name()<<endl;
	cout<<typeid(AddHead<MakeType<int,char>::result,MakeType<short,float>::result>::type).name()<<endl;
	cout<<"---------------AddHead test-----------------------------------------"<<endl;

	cout<<"---------------EraseOne test-----------------------------------------"<<endl;
	cout<<typeid(EraseOne<MakeType<int,int,char>::result,int>::type).name()<<endl;
	cout<<typeid(EraseOne<MakeType<int,char>::result,float>::type).name()<<endl;
	cout<<"---------------EraseOne test-----------------------------------------"<<endl;

	cout<<"---------------EraseAll test------------------------------------------"<<endl;
	cout<<typeid(EraseAll<MakeType<char,int,int,int,int,short>::result, int>::type).name()<<endl;
	cout<<"---------------EraseAll test------------------------------------------"<<endl;

	cout<<"---------------NoDuplicates test-------------------------------------"<<endl;
	cout<<typeid(NoDuplicates<MakeType<char,int,int,int,int,short>::result>::type).name()<<endl;
	cout<<"---------------NoDuplicates test-------------------------------------"<<endl;

	return 0;
}