boost.tuple源码整理和使用说明

Introduction

A tuple (or n-tuple) is a fixed size collection of elements. Pairs, triples, quadruples etc. are tuples. In a programming language, a tuple is a data object containing other objects as elements. These element objects may be of different types.

Tuples are convenient in many circumstances. For instance, tuples make it easy to define functions that return more than one value.

Some programming languages, such as ML, Python and Haskell, have built-in tuple constructs. Unfortunately C++ does not. To compensate for this "deficiency", the Boost Tuple Library implements a tuple construct using templates.

Source

#ifndef KIMI_TUPLE

#define KIMI_TUPLE

//依赖的其他两个boost库

#include <boost/type_traits.hpp>

#include "boost/ref.hpp"

namespace kimi_boost

{

namespace tuple

{

//所有的前置声明

struct null_type;

template <bool If, class Then, class Else>struct IF;

template <class T> struct length;

template <int N, class T>struct element;

template <class T>struct access_traits;

template <class HT, class TT>struct cons;

template <class T> struct make_tuple_traits;

template <

class T0 = null_type, class T1 = null_type, class T2 = null_type,

class T3 = null_type, class T4 = null_type, class T5 = null_type,

class T6 = null_type, class T7 = null_type, class T8 = null_type,

class T9 = null_type>

class tuple;

namespace detail

{

template <class T> class non_storeable_type;

template <class T> struct wrap_non_storeable_type;

template < int N > struct get_class;

template <class T0, class T1, class T2, class T3, class T4,

class T5, class T6, class T7, class T8, class T9>

struct map_tuple_to_cons;

template <

class T0 = null_type, class T1 = null_type, class T2 = null_type,

class T3 = null_type, class T4 = null_type, class T5 = null_type,

class T6 = null_type, class T7 = null_type, class T8 = null_type,

class T9 = null_type>

struct make_tuple_mapper;

template<class T>

class generate_error;

}

inline const null_type cnull() { return null_type(); }

//实现

////////////////////////////////null_type////////////////////////////////////

////////////////////////////////null_type////////////////////////////////////

////////////////////////////////null_type////////////////////////////////////

//表示到了类型链的尾部

struct null_type{};

////////////////////////////////IF////////////////////////////////////

////////////////////////////////IF////////////////////////////////////

////////////////////////////////IF////////////////////////////////////

//template meta的选择逻辑

template <bool If, class Then, class Else>

struct IF

{

typedef Then RET;

};

template <class Then, class Else>

struct IF<false, Then, Else>

{

typedef Else RET;

};

////////////////////////////////length////////////////////////////////////

////////////////////////////////length////////////////////////////////////

////////////////////////////////length////////////////////////////////////

//来获得tuple的长度(即所含元素个数)

template<class T>

struct length {

static const int value = 1 + length<typename T::tail_type>::value;

};

template<>

struct length<tuple<> > {

static const int value = 0;

};

template<>

struct length<null_type> {

static const int value = 0;

};

////////////////////////////////element////////////////////////////////////

////////////////////////////////element////////////////////////////////////

////////////////////////////////element////////////////////////////////////

//element<N,cons<...> >::type是cons中第N个元素的类型

template<int N, class T>// 这个int N会递减，以呈现递归的形式

struct element

{

private:

//T是cons<...>类型鸥

// cons<>内部有两个关键的typedef：head_type、tail_type

// typedef HT head_type;

// typedef TT tail_type;

typedef typename T::tail_type Next;

public:

typedef typename element<N-1, Next>::type type;//递归

};

//0的特化

template<class T>

struct element<0,T>

{

//递归至N=0时，山穷水尽

// 山穷水尽时直接将head_type定义为type

typedef typename T::head_type type;

};

//const T的特化

template<int N, class T>

struct element<N, const T>

{

private:

typedef typename T::tail_type Next;

typedef typename element<N-1, Next>::type unqualified_type;

public:

typedef typename boost::add_const<unqualified_type>::type type;

};

//0和const T的特化

template<class T>

struct element<0,const T>

{

typedef typename boost::add_const<typename T::head_type>::type type;

};

////////////////////////////////access_traits////////////////////////////////////

////////////////////////////////access_traits////////////////////////////////////

////////////////////////////////access_traits////////////////////////////////////

//access_traits<T>::parameter_type在tuple的构造函数中使用

template <class T>

struct access_traits

{

typedef const T& const_type;

typedef T& non_const_type;

//parameter_type在tuple的构造函数中使用

//remove_cv去掉const和volatile属性

//再加上const &属性

//为什么要作这么麻烦的举动，就是因为你可能会将常量或临时对象作为参数传递给构造函数，

//而C++标准不允许它们绑定到非const引用。

//为什么要用引用型别作参数型别？自然是为了效率着想。

typedef const typename boost::remove_cv<T>::type& parameter_type;

};

//因为不存在引用的引用，所有要有一个针对引用的偏特化版本

template <class T>

struct access_traits<T&>

{

typedef T& const_type;

typedef T& non_const_type;

typedef T& parameter_type;

};

namespace detail {

////////////////////////////////wrap_non_storeable_type////////////////////////////////////

////////////////////////////////wrap_non_storeable_type////////////////////////////////////

////////////////////////////////wrap_non_storeable_type////////////////////////////////////

//用来侦测你是否使用了void型别和函数类型

//因为这两种型别不能像int那样定义它们的变量

template <class T>

struct wrap_non_storeable_type

{

// 如果为函数类型则特殊处理

// 如果不是函数类型则type就是T

typedef typename IF<

::boost::is_function<T>::value, non_storeable_type<T>, T

>::RET type;

};

template <>

struct wrap_non_storeable_type<void>

{

// 如果为void型也特殊处理

typedef non_storeable_type<void> type;

};

////////////////////////////////non_storeable_type////////////////////////////////////

////////////////////////////////non_storeable_type////////////////////////////////////

////////////////////////////////non_storeable_type////////////////////////////////////

//函数型别和void型别的外覆类，以使得它们可以合法的作为数据成员被定义

template <class T> class non_storeable_type