使用c++11改写loki的TypeList

最近看了C++11的一些特性，最感兴趣的是可变模板参数，自动类型推断和匿名函数。

Loki中的TypeList，是需要递归定义的，并且需要一个NullType作为尾节点。

可变模板参数使得实现TypeList更简洁，更易懂。

以下是我用C++11实现TypeList,其实只用了可变模板参数。

去掉了递归定义，特别是尾节点可直接使用typelist<>,使得整个语义很美。

    //////////////////////////////////////////////////////////
    template<typename... TList>
    struct typelist
    {
    };

    typedef typelist<> nulllist;

    //////////////////////////////////////////////////////////
    template<typename... TList> struct length;

    template<typename... TList>
    struct length< typelist<TList...> >
    {
        enum { value = sizeof...(TList) };
    };

    //////////////////////////////////////////////////////////
    template<typename T, typename... TList> struct push_front;

    template<typename T, typename... TList>
    struct push_front< T, typelist<TList...> >
    {
        typedef typelist<T, TList...>  type;
    };


    //////////////////////////////////////////////////////////
    template<typename... TList> struct pop_front;

    template<typename T, typename... TList>
    struct pop_front< typelist<T, TList...> >
    {
        typedef typelist<TList...> type;
    };

    template<>
    struct pop_front< nulllist >
    {
        typedef nulllist type;
    };


    //////////////////////////////////////////////////////////
    template<unsigned int N, typename... TList> struct at;

    template<unsigned int N, typename T, typename... TList>
    struct at< N, typelist<T, TList...> >
    {
        typedef typename at< N-1, typelist<TList...> >::type type;
    };

    template<typename T, typename... TList>
    struct at< 0, typelist<T, TList...> >
    {
        typedef T type;
    };

    template<>
    struct at< 0, nulllist >
    {
        typedef nulllist type;
    };

    //////////////////////////////////////////////////////////
    template<int A, int B>
    struct IndexFixer
    {
        enum { value = (A == B) ? B : A + 1 };
    };

    //////////////////////////////////////////////////////////
    template<typename T, typename... TList> struct indexof;

    template<typename T, typename H, typename... TList>
    struct indexof< T, typelist<H, TList...> >
    {
        enum { value = IndexFixer<indexof<T, typelist<TList...>>::value, -1>::value };
    };

    template<typename T, typename... TList>
    struct indexof< T, typelist<T, TList...> >
    {
        enum { value = 0 };
    };

    template<typename T>
    struct indexof< T, nulllist >
    {
        enum { value = -1 };
    };

    //////////////////////////////////////////////////////////
    template<typename A, typename B> struct concat;

    template<typename... A, typename... B>
    struct concat<typelist<A...>, typelist<B...> >
    {
        typedef typelist<A..., B...> type;
    };

    template<typename T, typename... TList>
    struct concat<typelist<TList...>, T >
    {
        typedef typelist<TList..., T> type;
    };

    template<typename T, typename... TList>
    struct concat< T, typelist<TList...> >
    {
        typedef typelist<T, TList...>  type;
    };



    //////////////////////////////////////////////////////////
    template<typename T, typename... TList> struct erase;

    template<typename T, typename H, typename... TList>
    struct erase<T, typelist<H, TList...> >
    {
        typedef typename concat<H, typename erase< T, typelist<TList...> >::type>::type type;
    };

    template<typename T, typename... TList>
    struct erase<T, typelist<T, TList...> >
    {
        typedef typelist<TList...> type;
    };

    template<typename T>
    struct erase<T, nulllist >
    {
        typedef nulllist type;
    };

    //////////////////////////////////////////////////////////
    template<typename T, typename... TList> struct erase_all;

    template<typename T, typename H, typename... TList>
    struct erase_all<T, typelist<H, TList...> >
    {
        typedef typename concat<H, typename erase_all< T, typelist<TList...> >::type>::type type;
    };

    template<typename T, typename... TList>
    struct erase_all<T, typelist<T, TList...> >
    {
        typedef typename erase_all< T,typelist<TList...> >::type type;
    };

    template<typename T>
    struct erase_all<T, nulllist >
    {
        typedef nulllist type;
    };


    //////////////////////////////////////////////////////////
    template<typename T, typename...TList> struct no_duplicate;

    template<typename T, typename...TList>
    struct no_duplicate< typelist<T, TList...> >
    {
    private:
        typedef typename no_duplicate< typelist<TList...> >::type inner;
        typedef typename erase<T, inner>::type inner_result;
    public:
        typedef typename concat<T, inner_result>::type type;
    };

    template<>
    struct no_duplicate< nulllist >
    {
        typedef nulllist type;
    };


    //////////////////////////////////////////////////////////
    template<typename R, typename T, typename...TList> struct replace;

    template<typename R, typename T, typename H, typename...TList>
    struct replace<R, T, typelist<H, TList...> >
    {
        typedef typename concat<H, typename replace<R, T, typelist<TList...>>::type>::type type;
    };

    template<typename R, typename H, typename...TList>
    struct replace<R, H, typelist<H, TList...> >
    {
        typedef typename concat<R, typelist<TList...> >::type type;
    };

    template<typename R, typename T>
    struct replace<R, T, nulllist >
    {
        typedef nulllist type;
    };

    //////////////////////////////////////////////////////////
    template<typename R, typename T, typename...TList> struct replace_all;

    template<typename R, typename T, typename H, typename...TList>
    struct replace_all<R, T, typelist<H, TList...> >
    {
        typedef typename concat<H, typename replace_all<R, T, typelist<TList...>>::type>::type type;
    };

    template<typename R, typename H, typename...TList>
    struct replace_all<R, H, typelist<H, TList...> >
    {
        typedef typename concat<R, typename replace_all<R, H, typelist<TList...>>::type >::type type;
    };

    template<typename R, typename T>
    struct replace_all<R, T, nulllist >
    {
        typedef nulllist type;
    };

    //////////////////////////////////////////////////////////
    template<typename T, typename...TList> struct reverse;

    template<typename T, typename...TList>
    struct reverse<typelist<T, TList...> >
    {
        typedef typename concat<typename reverse<typelist<TList...>>::type, T>::type type;
    };

    template<>
    struct reverse< nulllist >
    {
        typedef nulllist type;
    };

 

例子：

#include <iostream>
#include <vector>
#include "TypeList.h"
#include <type_traits>

int main()
{
    typedef typelist<int, float, bool, float> testlist;
    typedef typelist<float, bool> tlist;
    typedef typelist<int, float> hlist;
    typedef typelist<> elist;
    typedef typelist<int> ilist;
    typedef testlist mylist;

    std::cout << "length: " << length<mylist>::value << std::endl;
    bool b;
    b = std::is_same<at<2, mylist>::type, bool>::value;
    std::cout << "is same: " << b << std::endl;
    b = std::is_same<push_front<int, elist>::type, ilist>::value;
    std::cout << "is same: " << b << std::endl;
    std::cout << "indexof : " << indexof<bool, mylist>::value << std::endl;
    b = std::is_same<pop_front<typelist<>>::type, pop_front<ilist>::type>::value ;
    std::cout << "is same: " << b << std::endl;
    b = std::is_same< erase<bool, mylist>::type, typelist<int, float, float>>::value;
    std::cout << "is same: " << b << std::endl;
    b = std::is_same< no_duplicate<mylist>::type, typelist<int, float, bool>>::value;
    std::cout << "is same: " << b << std::endl;
    b = std::is_same< replace<double, bool, mylist>::type, typelist<int, float, double, float>>::value;
    std::cout << "is same: " << b << std::endl;
    b = std::is_same< replace_all<double, float, mylist>::type, typelist<int, double, bool, double>>::value;
    std::cout << "is same: " << b << std::endl;
    b = std::is_same< reverse<mylist>::type, typelist<float, bool, float, int>>::value;
    std::cout << "is same: " << b << std::endl;

    //std::cout << "is same: " << CompileTimeCount(int) << std::endl;
    //std::cout << "is same: " << CompileTimeCount(int) << std::endl;
    return 0;
}