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

最新推荐文章于 2023-11-03 22:57:16 发布

转载最新推荐文章于 2023-11-03 22:57:16 发布 · 203 阅读

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/joeylee97/p/8877246.html

本文深入探讨了C++标准库中的std::tuple类模板，它是一种固定大小的异构值集合，可视为std::pair的泛化。文章详细介绍了tuple的实现思路，包括不定参数模板和模板偏特化的使用，以及如何通过递归基类结构来维护元素的下标，从而实现元素的存取。此外，还提供了源码级别的解析，帮助读者理解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();    
    }

转载于:https://www.cnblogs.com/joeylee97/p/8877246.html