c++11 关于typelist的foreach

建好一个typelist，其中都是类型信息而已，很重要的一个应用，循环迭代干些事情。

看了下boost的for_each实现，用我自己的typelist，大概代码如下：

    template<typename TList, typename F>
    void foreach_f(const F& f, TList* s = )
    {
        typedef typename front<TList>::type head_type;
        typedef typename pop_front<TList>::type tail_type;
        head_type  head_arg;
        f(head_arg);
        foreach_f(f, static_cast<tail_type*>());
    }

    template<typename F>
    void foreach_f(const F&, nulllist* s = )
    {

    }

例子：

struct print_t
{
    template<typename T>
    void operator() (T& t) const
    {
        std::cout << typeid(T).name() << std::endl;
    }
};

int main()
{
    typedef typelist<int, float, bool> statelist;
    foreach_f<statelist>(print_t());
}

我不喜欢的是实现中，要初始化一个参数类型，即：

head_type  head_arg;
f(head_arg);

这不如直接迭代一个tuple。

免去这步初始化，也可以这么做，虽然也不怎么喜欢：

    template<template<class> class F, typename... TList> struct foreach_t;

    template<template<class> class F, typename... TList>
    struct foreach_t<F, typelist<TList...>>
    {
        typedef typelist<TList...> type_list;
        typedef typename front<type_list>::type head_type;
        typedef typename pop_front<type_list>::type tail_type;

        static void apply()
        {
            F<head_type> f;
　　　　　　  f();
            return foreach_t<F, tail_type>::apply();
        }
    };

    template<template<class> class F>
    struct foreach_t<F, nulllist>
    {
        static void apply() {}
    };

使用一个模板类作为functor。

F<head_type> f;
f();

仍是不得不构造一个实例出来。而且比较难于保存信息。因为F<head_type>()是个临时变量。

不过这里很好玩的一个地方,这是一个类似函数语言的无边界效果的调用.没有副作用,却也没能发挥多少作用.