模板之Typelist的"增删改查"

向右看齐 2022-08-14 01:49 106阅读 0赞

### 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;
    }