c++11 一个简易的tuple实现

浏览数：27 / 时间：2015年06月08日

实现一个简易版的c++11 tuple。

我使用的编译器是gcc，codeblocks13.12自带的，哪个版本我不熟gcc也没去查。

大致看了下他家的tuple实现，多继承，tuple之上还有2个辅助类，走的是类似loki中GenScatterHierarchy的路子。1092行代码，不是盖的。。。

有些强迫症，不打算用多继承，，虽然并不会实例化来，看着闹心。

只考虑实现到POD类型的基本支持就行了，什么右值之类的我还没看到，就不搞了，仅供参考。

个人觉得tuple保存POD类型值就足够了，泛滥就堕落了。

gcc下出现一个reorder警告，不知道vs有没有。递归继承，构造函数带可变参数造成的。

单继承版本确实比多继承版本美得多了，可变模板参数真是个好东西。

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

    template<> struct tuple<> {};

    typedef tuple<> nulltuple;


    //////////////////////////////////////////////////////////
    template<typename T, typename... TList>
    struct tuple<T, TList...> : public tuple<TList...>
    {
        typedef T value_type;
        typedef tuple<TList...> base_type;

        tuple(T v, TList... tails):_value(v),base_type(tails...) {}

        const T& head() const { return this->_value; }
        T& head() { return this->_value; }

    protected:
        T _value;
    };

    template<typename T>
    struct tuple<T> : public nulltuple
    {
        typedef T value_type;
        typedef nulltuple base_type;

        tuple(T v):_value(v) {}

        const T& head() const { return this->_value; }
        T& head() { return this->_value; }

    protected:
        T _value;
    };


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

    template<unsigned int N, typename T, typename... TList>
    struct tuple_at< N, tuple<T, TList...> >
    {
        typedef typename tuple_at< N-1, tuple<TList...> >::value_type value_type;
        typedef typename tuple_at< N-1, tuple<TList...> >::tuple_type tuple_type;
    };

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

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

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

    template<unsigned int N, typename T, typename... TList>
    struct tuple_helper<N, tuple<T, TList...>>
    {
        typedef tuple<T, TList...> tuple_type;
        typedef typename tuple_at<N, tuple_type>::tuple_type base_tuple_type;
        typedef typename tuple_at<N, tuple_type>::value_type return_type;

        constexpr static const return_type& get(const tuple_type& tuple_)
        {
            return static_cast<const base_tuple_type&>(tuple_).head();
        }

        static void get(const nulltuple& tuple_) {}
    };

    //////////////////////////////////////////////////////////
    template<unsigned int N, typename... TList>
    constexpr const typename tuple_at<N, tuple<TList...> >::value_type&
    tuple_get(const tuple<TList...>& tuple_)
    {
        return tuple_helper< N, tuple<TList...> >::get(tuple_);
    }

例子：

#include "TypeTuple.h"
#include <tuple>

int main()
{
    bool b;
    tuple<int, float, char> pp = {10, 0.1234, ‘a‘};
    b = std::is_same<tuple_at<2, tuple<int, float, char>>::value_type, char >::value;
    std::cout << "is same: " << b << std::endl;
    b = std::is_same<tuple_at<2, tuple<int, float, char>>::tuple_type, tuple<char> >::value;
    std::cout << "is same: " << b << std::endl;
    std::cout << tuple_get<0>(pp)<<" "<< tuple_get<1>(pp) <<" "<<tuple_get<2>(pp) << std::endl;
    std::tuple<int, float, char> cc{10, 0.1234, ‘a‘};
    std::cout << sizeof(pp) << "  " << sizeof(cc) << std::endl;
    tuple<int, float, char> ppc = pp;
    std::cout << tuple_get<0>(ppc)<<" "<< tuple_get<1>(ppc) <<" "<<tuple_get<2>(ppc) << std::endl;
    return 0;
}