C++11 標準庫源代碼剖析：連載之七

std::tuple

tuple簡史

C++ Reference對tuple的解釋是“fixed-size collection of heterogeneous values”，也就是有固定長度的異構(gòu)數(shù)據(jù)的集合。每一個C++代碼仔都很熟悉的std::pair就是一種tuple。但是std::pair只能容納兩個數(shù)據(jù)，而C++11標準庫中定義的tuple可以容納任意多個、任意類型的數(shù)據(jù)。

tuple的用法

C++ 11標準庫中的tuple是一個模板類，使用時需要包含頭文件<tuple>：

#include <tuple>

using tuple_type = std::tuple<int, double, char>;
tuple_type t1(1, 2.0, 'a');

不過我們一般都用std::make_tuple函數(shù)來創(chuàng)建一個tuple，使用std::make_tuple的好處是不需要指定tuple參數(shù)的類型，編譯器會自己推斷：

#include <iostream>
#include <tuple>

auto t1 = std::make_tuple(1, 2.0, 'a');
std::cout << typeid(t1).name() << std::endl

可以使用std::get函數(shù)取出tuple中的數(shù)據(jù)：

auto t = std::make_tuple(1, 2.0, 'a');
std::cout << std::get<0>(t) << ", " << std::get<1>(t) << ", " << std::get<2>(t) << std::endl; // 1, 2.0, a

C++ 11標準庫中還定義了一些輔助類，方便我們?nèi)〉靡粋€tuple類的信息：

using tuple_type = std::tuple<int, double, char>;

// tuple_size: 在編譯期獲得tuple元素個數(shù)
cout << std::tuple_size<tuple_type>::value << endl; // 3

// tuple_element: 在編譯期獲得tuple的元素類型
cout << typeid(std::tuple_element<2, tuple_type>::type).name() << endl; // c

關(guān)于tuple的用法就簡要介紹到這里，C++ Reference上有關(guān)于std::tuple的詳細介紹，感興趣的同學(xué)可以去看看。下面我們著重講一下tuple的實現(xiàn)原理。

tuple的實現(xiàn)原理

如果你對boost::tuple有所了解的話，應(yīng)該知道boost::tuple是使用遞歸嵌套實現(xiàn)的，這也是大多數(shù)類庫--比如Loki和 MS VC--實現(xiàn)tuple的方法。而libc++另辟蹊徑，采用了多重繼承的手法實現(xiàn)。libc++的tuple的源代碼極其復(fù)雜，大量使用了元編程技巧，如果我一行行解讀這些源代碼，那本章就會變成C++模板元編程入門。為了讓你有繼續(xù)看下去的勇氣，我將libc++ tuple的源代碼簡化，實現(xiàn)了一個極簡版tuple，希望能幫助你理解tuple的工作原理。

tuple_size

我們先從輔助類開始：

// forward declaration
template<class ...T> class tuple;

template<class ...T> class tuple_size;

// 針對tuple類型的特化
template<class ...T>
class tuple_size<tuple<T...> > : public std::integral_constant<size_t, sizeof...(T)> {};

這個比較好理解，如果tuple_size作用于一個tuple，則tuple_size的值就是sizeof...(T)的值。所以你可以這樣寫：

cout << tuple_size<tuple<int, double, char> >::value << endl;    // 3

tuple_types

下一個輔助類就是tuple_types：

template<class ...T> struct tuple_types{};

template<class T, size_t End = tuple_size<T>::value, size_t Start = 0>
struct make_tuple_types {};

template<class ...T, size_t End>
struct make_tuple_types<tuple<T...>, End, 0> {
    typedef tuple_types<T...> type;
};

template<class ...T, size_t End>
struct make_tuple_types<tuple_types<T...>, End, 0> {
        typedef tuple_types<T...> type;
};

這個簡化版的typle_types并不做具體的事，就是純粹的類型定義。需要說明的是，如果你要使用這個簡化版的tuple_types，最好保證End == sizeof...(T) - 1，否則有可能編譯器會報錯。

type_indices

下面這個有點復(fù)雜：

template<size_t ...value> struct tuple_indices {};

template<class IndexType, IndexType ...values>
struct integer_sequence {
    template<size_t Start>
    using to_tuple_indices = tuple_indices<(values + Start)...>;
};

template<size_t End, size_t Start>
using make_indices_imp = typename __make_integer_seq<integer_sequence, size_t, End - Start>::template to_tuple_indices<Start>;

template<size_t End, size_t Start = 0>
struct make_tuple_indices {
    typedef make_indices_imp<End, Start> type;
};

__make_integer_seq是LLVM編譯器的一個內(nèi)置的函數(shù)，它的作用--顧名思義--是在編譯期生成一個序列，如果你寫下這樣的代碼：

__mkae_integer_seq<integer_sequence, size_t, 3>

則編譯器會將它展開成：

integer_sequence<0>, integer_sequence<1>, integer_sequence<2>

所以，對于下面的代碼：

make_tuple_indices<3>

編譯器最終會展開成：

tuple_indices<0>, tuple_indices<1>, tuple_indices<2>

這樣就定義了一個tuple的索引。

tuple_element

最后一個輔助類是tuple_element：

namespace indexer_detail {
    template<size_t Index, class T>
    struct indexed {
        using type = T;
    };
        
    template<class Types, class Indexes> struct indexer;
        
    template<class ...Types, size_t ...Index>
    struct indexer<tuple_types<Types...>, tuple_indices<Index...> > : public indexed<Index, Types>... {};
        
    template<size_t Index, class T>
    indexed<Index, T> at_index(indexed<Index, T> const&);
} // namespace indexer_detail
    
template<size_t Index, class ...Types>
using type_pack_element = typename decltype(indexer_detail::at_index<Index>(
    indexer_detail::indexer<tuple_types<Types...>,
    typename make_tuple_indices<sizeof...(Types)>::type>{}))::type;
    
template<size_t Index, class ...T>
struct tuple_element<Index, tuple_types<T...> > {
    typedef type_pack_element<Index, T...> type;
};
    
template<size_t Index, class ...T>
struct tuple_element<Index, tuple<T...> > {
    typedef type_pack_element<Index, T...> type;
};

我知道上面的代碼又讓你頭暈?zāi)垦＃晕視敿毥忉屢幌?。如果你寫下這樣的代碼：

tuple_element<1, tuple<int, double, char> >::type

編譯器會展開成（省略那些煩人的namespace限定符后）：tuple_pack_element<1, int, double, char>，進而展開成

decltype(
    at_index<1>(indexer<tuple_types<int, double, char>, tuple_indices<3>>{})
)

注意，上面的代碼中定義了類indexer作為函數(shù)at_index的參數(shù)，而函數(shù)at_index只接受at_index類型的參數(shù)，于是編譯器會來個向上轉(zhuǎn)型，將indexer向上轉(zhuǎn)型成indexed<1,double>（仔細想想為什么？），而indexed<1, double>::type就是double。

看似很復(fù)雜，其實無非就是文字代換而已。

tuple

好了，酒水備齊了，下面上主菜：

template<size_t Index, class Head>
class tuple_leaf {
    Head value;

public:
    tuple_leaf() : vlaue(){}
    
    template<class T>
    explicit tuple_leaf(cosnt T& t) : value(t){}
    
    Head& get(){return value;}
    const Head& get() const {return value;}
};

tuple_leaf是tuple的基本組成單位，每一個tuple_leaf都保存了一個索引（就是第一個模板參數(shù)），同時還有值。

繼續(xù)看：

template<class Index, class ...T> struct tuple_imp;

template<size_t ...Index, class ...T>
struct tuple_imp<tuple_indices<Index...>, T...> : 
    public tuple_leaf<Index, T>... {
    
    tuple_imp(){}
    
    template<size_t ...Uf, class ...Tf, class ...U>
    tuple_imp(tuple_indices<Uf...>, tuple_types<Tf...>, U&& ...u) 
        : tuple_leaf<Uf, Tf>(std::forward<U>(u))... {}
};

template<class ...T>
struct tuple {
    typedef tuple_imp<typename make_tuple_indices<sizeof...(T)>::type, T...> base;
    
    base base_;
    
    tuple(const T& ...t)
        : base(typename make_tuple_indices<sizeof...(T)>::type(),
               typename make_tuple_types<tuple, sizeof...(T)>::type(),
               t...){}
};

看到了吧，每一個tuple都繼承自數(shù)個tuple_leaf。而前面說過，每個tuple_leaf都有索引和值，所以定義一個tuple所需要的信息都保存在這些tuple_leaf中。如果有這樣的代碼

tuple(1, 2.0, 'a')

編譯器會展開成

struct tuple_imp : public tuple_leaf<0, int>,       // value = 1
                   public tuple_leaf<1, double>     // value = 2.0
                   public tuple_leaf<2, char>       // value = 'a'

是不是有種腦洞大開的感覺？

make_tuple 和 get

為了方便使用，標準庫還定義了函數(shù)make_tuple和get

// make_tuple

template<class T>
struct make_tuple_return_imp {
    typedef T type;
};

template<class T>
struct make_tuple_return {
    typedef typename make_tuple_return_imp<typename std::decay<T>::type>::type type;
};

template<class ...T>
inline tuple<typename make_tuple_return<T>::type...> make_tuple<T&& ...t) {
    return tuple<typename make_tuple_return<T>::type...>(std::forward<T>(t)...);
}

// get

template<size_t Index, class ...T>
inline typename tuple_element<Index, tuple<T...> >::type& get(tuple<T...>& t) {
    typedef typename tuple_element<Index, tuple<T...> >::type type;
    return static_cast<tuple_leaf<Index, type>&>(t.base_).get();

這些代碼我就不解釋了，留給你自己消化。

總結(jié)

本章展示的tuple只是個簡化版的示例而已，要實現(xiàn)工業(yè)強度的tuple，要做的工作還很多。有興趣的同學(xué)可以去看看libc++的源代碼。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容