从零开始写STL—模板元编程之tuple

tuple

Class template std::tuple is a fixed-size collection of heterogeneous values. It is a generalization of std::pair.

能够用来在bind中存储函数指针和参数

实现思路

不定参数模板 + 模板偏特化
tuple做为一个存储不定参数模板的类，分为一下几种偏特化形式：
template<>
struct tuple<> {};
template<typename T, typename... Args>
struct tuple<T, Args...> : public tuple<Args...>
template
struct tuple : public nulltuple
能够注意到每一个模板struct tuple<T, Args...> : public tuple<Args...>做为其上一级模板的子类来展开，这样在获取tuple_at时从前向后维护一个当前元素的下标计数来存取元素

源码

template<typename... Args> struct tuple;

    template<>
    struct tuple<> {};
    typedef tuple<> nulltuple;

    template<typename T, typename... Args>
    struct tuple<T, Args...> : public tuple<Args...>
    {
        typedef tuple<T, Args...> self_type;
        typedef tuple<Args...> base_type;
        typedef T value_type;
        tuple(const T& v, const Args&... tails) :base_type(tails...), value(v) {}
        tuple(T&& v, Args&&... tails) :base_type(std::move(tails)...), value(std::forward<T>(v)) {}
        tuple(T&& v, Args&... tails) :base_type(std::move(tails)...), value(std::forward<T>(v)) {}
        tuple(T& v, Args&&... tails) :base_type(std::move(tails)...), value(std::forward<T>(v)) {}

        T& getval() 
        {
            return value;
        }

        T value;
    };

    template<typename T>
    struct tuple<T> : public nulltuple
    {
        typedef T value_type;
        tuple(const T& val) :value(val) {}

        T& getval() 
        {
            return value;
        }

        T value;
    };
    template<size_t n, typename T> struct tuple_at;

    template<size_t n, typename T,typename... Args>
    struct tuple_at<n, tuple<T,Args...>>
    {
        typedef typename tuple_at<n - 1, tuple<Args...>>::value_type value_type;
        typedef typename tuple_at<n - 1, tuple<Args...>>::tuple_type tuple_type;
    };

    template<typename T,typename... Args>
    struct tuple_at<0, tuple<T,Args...>>
    {
        typedef T value_type;
        typedef typename tuple<T, Args...> tuple_type;
    };

    template<typename T>
    struct tuple_at<0, tuple<T>>
    {
        typedef T value_type;
        typedef typename tuple<T> tuple_type;
    };

    template<>
    struct tuple_at<0,tuple<>>
    {
        typedef tuple<> tuple_type;
        typedef tuple<> value_type;
    };

    template<size_t n,typename... Args>
    typename tuple_at<n, tuple<Args...>>::value_type& tuple_get(tuple<Args...>& t)
    {
        typedef typename tuple_at<n, tuple<Args...>>::tuple_type ret_tuple_type;
        return static_cast<ret_tuple_type&>(t).getval();    
    }