C++11 标准库源代码剖析：连载之七
std::tuple
tuple简史
C++ Reference对tuple的解释是“fixed-size collection of heterogeneous values”，也就是有固定长度的异构数据的集合。每一个C++代码仔都很熟悉的std::pair就是一种tuple。但是std::pair只能容纳两个数据，而C++11标准库中定义的tuple可以容纳任意多个、任意类型的数据。
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函数来创建一个tuple，使用std::make_tuple的好处是不需要指定tuple参数的类型，编译器会自己推断：
#include <iostream>
#include <tuple>
auto t1 = std::make_tuple(1, 2.0, 'a');
std::cout << typeid(t1).name() << std::endl
可以使用std::get函数取出tuple中的数据：
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标准库中还定义了一些辅助类，方便我们取得一个tuple类的信息：
using tuple_type = std::tuple<int, double, char>;
// tuple_size: 在编译期获得tuple元素个数
cout << std::tuple_size<tuple_type>::value << endl; // 3
// tuple_element: 在编译期获得tuple的元素类型
cout << typeid(std::tuple_element<2, tuple_type>::type).name() << endl; // c
关于tuple的用法就简要介绍到这里，C++ Reference上有关于std::tuple的详细介绍，感兴趣的同学可以去看看。下面我们着重讲一下tuple的实现原理。
tuple的实现原理
如果你对boost::tuple有所了解的话，应该知道boost::tuple是使用递归嵌套实现的，这也是大多数类库--比如Loki和 MS VC--实现tuple的方法。而libc++另辟蹊径，采用了多重继承的手法实现。libc++的tuple的源代码极其复杂，大量使用了元编程技巧，如果我一行行解读这些源代码，那本章就会变成C++模板元编程入门。为了让你有继续看下去的勇气，我将libc++ tuple的源代码简化，实现了一个极简版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
下面这个有点复杂：
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编译器的一个内置的函数，它的作用--顾名思义--是在编译期生成一个序列，如果你写下这样的代码：
__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;
};
我知道上面的代码又让你头晕目眩，所以我会详细解释一下。如果你写下这样的代码：
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作为函数at_index的参数，而函数at_index只接受at_index类型的参数，于是编译器会来个向上转型，将indexer向上转型成indexed<1,double>（仔细想想为什么？），而indexed<1, double>::type就是double。
看似很复杂，其实无非就是文字代换而已。
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都保存了一个索引（就是第一个模板参数），同时还有值。
继续看：
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都继承自数个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
为了方便使用，标准库还定义了函数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();
这些代码我就不解释了，留给你自己消化。
总结
本章展示的tuple只是个简化版的示例而已，要实现工业强度的tuple，要做的工作还很多。有兴趣的同学可以去看看libc++的源代码。
