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

原创 2007年10月07日 23:13:00

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<...> >::typecons中第N个元素的类型

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

   struct element

   {

   private:

      //Tcons<...>类型鸥

      // cons<>内部有两个关键的typedefhead_typetail_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;

   };

 

   //0const 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_typetuple的构造函数中使用

   template <class T>

   struct access_traits

   {

      typedef const T& const_type;

      typedef T& non_const_type;

      //parameter_typetuple的构造函数中使用

      //remove_cv去掉constvolatile属性

      //再加上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

      {

        non_storeable_type();

      };

      ////////////////////////////////get_class////////////////////////////////////

      ////////////////////////////////get_class////////////////////////////////////

      ////////////////////////////////get_class////////////////////////////////////

      //返回cons<HT, TT>& t中的第N个对象

      template< int N >

      struct get_class

      {

        template<class RET, class HT, class TT >

        inline static RET get(const cons<HT, TT>& t)

        {

           //这里的递归仍然是通过递减模板参数N实现

           //同时不断将t.tail传给get_class<N-1>::template get<RET>()直到N减为,

           //从而调用get_class<0>::get<RET>(),后者直接将t.head返回

 

           //tailcons的一个数据成员

           return get_class<N-1>::template get<RET>(t.tail);

        }

 

        template<class RET, class HT, class TT >

        inline static RET get(cons<HT, TT>& t)

        {

           return get_class<N-1>::template get<RET>(t.tail);

        }

      };

 

 

      template<>

      struct get_class<0> {

        template<class RET, class HT, class TT>

        inline static RET get(const cons<HT, TT>& t)

        {

           return t.head;

        }

        template<class RET, class HT, class TT>

        inline static RET get(cons<HT, TT>& t)

        {

           return t.head;

        }

      };

 

 

      ////////////////////////////////map_tuple_to_cons////////////////////////////////////

      ////////////////////////////////map_tuple_to_cons////////////////////////////////////

      ////////////////////////////////map_tuple_to_cons////////////////////////////////////

      //tuplecons建立了映射关系

      //递归的将一系列的类型定义为cons<...>的嵌套式的类型

      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

      {

        typedef cons<T0,

           typename map_tuple_to_cons<T1, T2, T3, T4, T5,

           T6, T7, T8, T9, null_type>::type

        > type;

      };

 

      // The empty tuple is a null_type

      template <>

      struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type,

        null_type, null_type, null_type, null_type>

      {

        typedef null_type type;

      };

      ////////////////////////////////make_tuple_mapper////////////////////////////////////

      ////////////////////////////////make_tuple_mapper////////////////////////////////////

      ////////////////////////////////make_tuple_mapper////////////////////////////////////

      //为了使make_tuple函数更短,使用的一个小技巧,所有的make_tuple函数都使用了它

      template <

        class T0 , class T1 , class T2 ,

        class T3 , class T4 , class T5 ,

        class T6 , class T7 , class T8 ,

        class T9

      >

      struct make_tuple_mapper {

        typedef

           tuple<typename make_tuple_traits<T0>::type,

           typename make_tuple_traits<T1>::type,

           typename make_tuple_traits<T2>::type,

           typename make_tuple_traits<T3>::type,

           typename make_tuple_traits<T4>::type,

           typename make_tuple_traits<T5>::type,

           typename make_tuple_traits<T6>::type,

           typename make_tuple_traits<T7>::type,

           typename make_tuple_traits<T8>::type,

           typename make_tuple_traits<T9>::type> type;

      };

   } // detail

   ////////////////////////////////get////////////////////////////////////

   ////////////////////////////////get////////////////////////////////////

   ////////////////////////////////get////////////////////////////////////

 

   //两个get函数

   //内部使用了get_class,返回了cons<HT, TT>& c对象中的第N个对象

   template<int N, class HT, class TT>

   inline typename access_traits<typename element<N, cons<HT, TT> >::type>::non_const_type

      get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N))

   {

      return

        detail::get_class<N>::template get<

           //get的第一个模版参数是返回类型,nonconstget返回nonconst类型对象

           typename access_traits<typename element<N, cons<HT, TT> >::type>::non_const_type,

           HT,

           TT

        >(c);

   }

 

 

   template<int N, class HT, class TT>

   inline typename access_traits<typename element<N, cons<HT, TT> >::type>::const_type

      get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N))

   {

      return detail::get_class<N>::template

        get<

        typename access_traits<

        typename element<N, cons<HT, TT> >::type

         >::const_type,

        HT,TT

        >(c);

   }

 

   ////////////////////////////////make_tuple_traits////////////////////////////////////

   ////////////////////////////////make_tuple_traits////////////////////////////////////

   ////////////////////////////////make_tuple_traits////////////////////////////////////

   template<class T>

   struct make_tuple_traits {

      typedef T type;

   };

 

   // The is_function test was there originally for plain function types,

   // which can't be stored as such (we must either store them as references or

   // pointers). Such a type could be formed if make_tuple was called with a

   // reference to a function.

   // But this would mean that a const qualified function type was formed in

   // the make_tuple function and hence make_tuple can't take a function

   // reference as a parameter, and thus T can't be a function type.

   // So is_function test was removed.

   // (14.8.3. says that type deduction fails if a cv-qualified function type

   // is created. (It only applies for the case of explicitly specifying template

   // args, though?)) (JJ)

 

   template<class T>

   struct make_tuple_traits<T&> {

      typedef typename

        detail::generate_error<T&>::

        do_not_use_with_reference_type error;

   };

 

   // Arrays can't be stored as plain types; convert them to references.

   // All arrays are converted to const. This is because make_tuple takes its

   // parameters as const T& and thus the knowledge of the potential

   // non-constness of actual argument is lost.

 

   //给数组加上const reference属性

   template<class T, int n>  struct make_tuple_traits <T[n]> {

      typedef const T (&type)[n];

   };

   //const数组加上const reference属性

   template<class T, int n>

   struct make_tuple_traits<const T[n]> {

      typedef const T (&type)[n];

   };

   //volatile数组加上const reference属性

   template<class T, int n>  struct make_tuple_traits<volatile T[n]> {

      typedef const volatile T (&type)[n];

   };

 

   //const volatile数组加上reference属性

   template<class T, int n>

   struct make_tuple_traits<const volatile T[n]> {

      typedef const volatile T (&type)[n];

   };

  

   //以下两个处理boost::reference_wrapper封装的引用类型

   template<class T>

   struct make_tuple_traits<boost::reference_wrapper<T> >{

      typedef T& type;

   };

 

   template<class T>

   struct make_tuple_traits<const boost::reference_wrapper<T> >{

      typedef T& type;

   };

   ////////////////////////////////cons////////////////////////////////////

   ////////////////////////////////cons////////////////////////////////////

   ////////////////////////////////cons////////////////////////////////////

   template <class HT, class TT>

   struct cons {

 

      typedef HT head_type;

      typedef TT tail_type;

 

      typedef typename

        detail::wrap_non_storeable_type<head_type>::type stored_head_type;

 

      stored_head_type head;//这是其中第一个数据成员

      tail_type tail;//第二个数据成员

 

 

      //constnon-const的个get函数

      typename access_traits<stored_head_type>::non_const_type

        get_head() { return head; }

 

      typename access_traits<tail_type>::non_const_type

        get_tail() { return tail; }

 

      typename access_traits<stored_head_type>::const_type

        get_head() const { return head; }

 

      typename access_traits<tail_type>::const_type

        get_tail() const { return tail; }

 

      //ctor

      cons() : head(), tail() {}

      cons(typename access_traits<stored_head_type>::parameter_type h,

        const tail_type& t)

        : head (h), tail(t) {}

 

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

      class T6, class T7, class T8, class T9, class T10>

        cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,

        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )

        : head (t1),

        tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())

      {}

 

      template <class T2, class T3, class T4, class T5,

      class T6, class T7, class T8, class T9, class T10>

        cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5,

        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )

        : head (),

        tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())

      {}

 

 

      template <class HT2, class TT2>

      cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}

 

      template <class HT2, class TT2>

      cons& operator=( const cons<HT2, TT2>& u ) {

        head=u.head; tail=u.tail; return *this;

      }

 

      // must define assignment operator explicitly, implicit version is

      // illformed if HT is a reference (12.8. (12))

      cons& operator=(const cons& u) {

        head = u.head; tail = u.tail;  return *this;

      }

 

      template <class T1, class T2>

      cons& operator=( const std::pair<T1, T2>& u ) {

        BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2

        head = u.first; tail.head = u.second; return *this;

      }

 

      // get member functions (non-const and const)

      template <int N>

      typename access_traits<

        typename element<N, cons<HT, TT> >::type

      >::non_const_type

      get() {

        return boost::tuples::get<N>(*this); // delegate to non-member get

      }

 

      template <int N>

      typename access_traits<

        typename element<N, cons<HT, TT> >::type

      >::const_type

      get() const {

        return boost::tuples::get<N>(*this); // delegate to non-member get

      }

   };

 

   template <class HT>

   struct cons<HT, null_type> {

 

      typedef HT head_type;

      typedef null_type tail_type;

      typedef cons<HT, null_type> self_type;

 

      typedef typename

        detail::wrap_non_storeable_type<head_type>::type stored_head_type;

      stored_head_type head;//唯一的成员变量

      // 注意,不像上面的主模板,这里没有tail成员

 

      typename access_traits<stored_head_type>::non_const_type

        get_head() { return head; }

 

      null_type get_tail() { return null_type(); }

 

      typename access_traits<stored_head_type>::const_type

        get_head() const { return head; }

 

      const null_type get_tail() const { return null_type(); }

 

      //  cons() : head(detail::default_arg<HT>::f()) {}

      cons() : head() {}

 

      cons(typename access_traits<stored_head_type>::parameter_type h,

        const null_type& = null_type())

        : head (h) {}

 

      template<class T1>

      cons(T1& t1, const null_type&, const null_type&, const null_type&,

        const null_type&, const null_type&, const null_type&,

        const null_type&, const null_type&, const null_type&)

        : head (t1) {}

 

      cons(const null_type&,

        const null_type&, const null_type&, const null_type&,

        const null_type&, const null_type&, const null_type&,

        const null_type&, const null_type&, const null_type&)

        : head () {}

 

      template <class HT2>

      cons( const cons<HT2, null_type>& u ) : head(u.head) {}

 

      template <class HT2>

      cons& operator=(const cons<HT2, null_type>& u )

      { head = u.head; return *this; }

 

      // must define assignment operator explicitely, implicit version

      // is illformed if HT is a reference

      cons& operator=(const cons& u) { head = u.head; return *this; }

 

      template <int N>

      typename access_traits<

        typename element<N, self_type>::type

      >::non_const_type

      get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {

        return boost::tuples::get<N>(*this);

      }

 

      template <int N>

      typename access_traits<

        typename element<N, self_type>::type

      >::const_type

      get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {

        return boost::tuples::get<N>(*this);

      }

 

   };

 

 

   ////////////////////////////////tuple////////////////////////////////////

   ////////////////////////////////tuple////////////////////////////////////

   ////////////////////////////////tuple////////////////////////////////////

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

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

 

   class tuple :

      public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type

   {

   public:

      typedef typename

        detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;

      typedef typename inherited::head_type head_type;

      typedef typename inherited::tail_type tail_type;

 

 

      // access_traits<T>::parameter_type takes non-reference types as const T&

      tuple() {}

 

      tuple(typename access_traits<T0>::parameter_type t0)

        : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull(), detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1)

        : inherited(t0, t1, detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull(), detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1,

        typename access_traits<T2>::parameter_type t2)

        : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1,

        typename access_traits<T2>::parameter_type t2,

        typename access_traits<T3>::parameter_type t3)

        : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull(), detail::cnull(),

        detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1,

        typename access_traits<T2>::parameter_type t2,

        typename access_traits<T3>::parameter_type t3,

        typename access_traits<T4>::parameter_type t4)

        : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull(), detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1,

        typename access_traits<T2>::parameter_type t2,

        typename access_traits<T3>::parameter_type t3,

        typename access_traits<T4>::parameter_type t4,

        typename access_traits<T5>::parameter_type t5)

        : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),

        detail::cnull(), detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1,

        typename access_traits<T2>::parameter_type t2,

        typename access_traits<T3>::parameter_type t3,

        typename access_traits<T4>::parameter_type t4,

        typename access_traits<T5>::parameter_type t5,

        typename access_traits<T6>::parameter_type t6)

        : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),

        detail::cnull(), detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1,

        typename access_traits<T2>::parameter_type t2,

        typename access_traits<T3>::parameter_type t3,

        typename access_traits<T4>::parameter_type t4,

        typename access_traits<T5>::parameter_type t5,

        typename access_traits<T6>::parameter_type t6,

        typename access_traits<T7>::parameter_type t7)

        : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),

        detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1,

        typename access_traits<T2>::parameter_type t2,

        typename access_traits<T3>::parameter_type t3,

        typename access_traits<T4>::parameter_type t4,

        typename access_traits<T5>::parameter_type t5,

        typename access_traits<T6>::parameter_type t6,

        typename access_traits<T7>::parameter_type t7,

        typename access_traits<T8>::parameter_type t8)

        : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}

 

      tuple(typename access_traits<T0>::parameter_type t0,

        typename access_traits<T1>::parameter_type t1,

        typename access_traits<T2>::parameter_type t2,

        typename access_traits<T3>::parameter_type t3,

        typename access_traits<T4>::parameter_type t4,

        typename access_traits<T5>::parameter_type t5,

        typename access_traits<T6>::parameter_type t6,

        typename access_traits<T7>::parameter_type t7,

        typename access_traits<T8>::parameter_type t8,

        typename access_traits<T9>::parameter_type t9)

        : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}

 

 

      template<class U1, class U2>

      tuple(const cons<U1, U2>& p) : inherited(p) {}

 

      template <class U1, class U2>

      tuple& operator=(const cons<U1, U2>& k) {

        inherited::operator=(k);

        return *this;

      }

 

      template <class U1, class U2>

      tuple& operator=(const std::pair<U1, U2>& k) {

        BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2

        this->head = k.first;

        this->tail.head = k.second;

        return *this;

      }

 

   };

 

   // The empty tuple

   template <>

   class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>  :

      public null_type

   {

   public:

      typedef null_type inherited;

   };

 

 

 

 

 

 

   ////////////////////////////////make_tuple////////////////////////////////////

   ////////////////////////////////make_tuple////////////////////////////////////

   ////////////////////////////////make_tuple////////////////////////////////////

   //make_tuple函数,产生一个临时的tuple对象

 

   template<class T0>

   inline typename detail::make_tuple_mapper<T0>::type

      make_tuple(const T0& t0) {

        typedef typename detail::make_tuple_mapper<T0>::type t;

        return t(t0);

   }

 

   template<class T0, class T1>

   inline typename detail::make_tuple_mapper<T0, T1>::type

      make_tuple(const T0& t0, const T1& t1) {

        typedef typename detail::make_tuple_mapper<T0, T1>::type t;

        return t(t0, t1);

   }

 

   template<class T0, class T1, class T2>

   inline typename detail::make_tuple_mapper<T0, T1, T2>::type

      make_tuple(const T0& t0, const T1& t1, const T2& t2) {

        typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;

        return t(t0, t1, t2);

   }

 

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

   inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type

      make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {

        typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;

        return t(t0, t1, t2, t3);

   }

 

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

   inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type

      make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,

      const T4& t4) {

        typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;

        return t(t0, t1, t2, t3, t4);

   }

 

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

   inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type

      make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,

      const T4& t4, const T5& t5) {

         typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;

        return t(t0, t1, t2, t3, t4, t5);

   }

 

   template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>

   inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type

      make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,

      const T4& t4, const T5& t5, const T6& t6) {

        typedef typename detail::make_tuple_mapper

           <T0, T1, T2, T3, T4, T5, T6>::type t;

        return t(t0, t1, t2, t3, t4, t5, t6);

   }

 

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

   class T7>

      inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type

      make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,

      const T4& t4, const T5& t5, const T6& t6, const T7& t7) {

        typedef typename detail::make_tuple_mapper

           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;

        return t(t0, t1, t2, t3, t4, t5, t6, t7);

   }

 

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

   class T7, class T8>

      inline typename detail::make_tuple_mapper

      <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type

      make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,

      const T4& t4, const T5& t5, const T6& t6, const T7& t7,

      const T8& t8) {

        typedef typename detail::make_tuple_mapper

           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;

        return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);

   }

 

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

   class T7, class T8, class T9>

      inline typename detail::make_tuple_mapper

      <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type

      make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,

      const T4& t4, const T5& t5, const T6& t6, const T7& t7,

      const T8& t8, const T9& t9) {

        typedef typename detail::make_tuple_mapper

           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;

        return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);

   }

 

 

 

   ////////////////////////////////tie////////////////////////////////////

   ////////////////////////////////tie////////////////////////////////////

   ////////////////////////////////tie////////////////////////////////////

   // Tie function templates -------------------------------------------------

   //专门用来生成元素是引用类型的tuple

   template<class T1>

   inline tuple<T1&> tie(T1& t1) {

      return tuple<T1&> (t1);

   }

 

   template<class T1, class T2>

   inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {

      return tuple<T1&, T2&> (t1, t2);

   }

 

   template<class T1, class T2, class T3>

   inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {

      return tuple<T1&, T2&, T3&> (t1, t2, t3);

   }

 

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

   inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {

      return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);

   }

 

   template<class T1, class T2, class T3, class T4, class T5>

   inline tuple<T1&, T2&, T3&, T4&, T5&>

      tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {

        return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);

   }

 

   template<class T1, class T2, class T3, class T4, class T5, class T6>

   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>

      tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {

        return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);

   }

 

   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>

   inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>

      tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {

        return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);

   }

 

   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,

   class T8>

      inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>

      tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {

        return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>

           (t1, t2, t3, t4, t5, t6, t7, t8);

   }

 

   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,

   class T8, class T9>

      inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>

      tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,

      T9& t9) {

        return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>

           (t1, t2, t3, t4, t5, t6, t7, t8, t9);

   }

 

   template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,

   class T8, class T9, class T10>

      inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>

      tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,

      T9& t9, T10& t10) {

        return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>

           (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);

   }

}

}//namespace kimi_boost

 

#endif//KIMI_TUPLE

Test code

   using namespace kimi_boost::tuple;

   tuple<int,float,double> t2 = make_tuple(666, 666.666f, 777.777);

 

 

   int ival=10;  long lval=10; bool bval=true;

 

   tuple<int&,long&,bool&> MyTuple=tie(ival,lval,bval);

   ival=5;

   lval=20;

   bval=false;

Output

 

boost源码剖析之:Tuple Types(rev#2)

boost源码剖析之:Tuple Types(rev#2) 刘未鹏(pongba) C++的罗浮宫(http://blog.csdn.net/pongba) Note: 并非新作,04年...
  • vsooda
  • vsooda
  • 2012年03月24日 13:27
  • 487

Boost源码剖析之:增强的std::pair--Tuple Types (一)

0 动机[1] 假设你有这样一个函数:它接受两个整型数据并返回它们整除的结果,像这样: int DevideInts(int n,int d) { return n/d...

windows下boost怎样安装与使用说明

第1步: 先从官网(www.boost.org)下载最新版的BOOST源码,如图所示 随便下哪个都行,我这里下的是82M的那个 第2步: 编译源代码(放心.这里是傻瓜式的操作,很容易操作) (1)...
  • sum0000
  • sum0000
  • 2013年09月11日 09:46
  • 2557

windows下boost怎样安装与使用说明?

第1步: 先从官网(www.boost.org)下载最新版的BOOST源码,如图所示 随便下哪个都行,我这里下的是82M的那个 第2步: 编译源代码(放心.这里是傻瓜式的操作,很容易操作) ...

Boost1.58—— thread组件使用说明

1、系统环境Ubuntu14.04 LTS g++-4.82、示例代码example.cpp#include #include void task1() { // do stu...
  • IvanLJF
  • IvanLJF
  • 2017年04月26日 17:00
  • 679

boost库asio详解5——resolver与endpoint使用说明

tcp::resolver一般和tcp::resolver::query结合用,通过query这个词顾名思义就知道它是用来查询socket的相应信息,一般而言我们关心socket的东东有address...

I2C-Tools 4.0使用说明及android平台移植,提供源码下载路径

I2C-Tools (4.0) The I2C tools that used to be part of the lm-sensors package have been split to a se...

word2vec中文相似词计算和聚类的使用说明及c语言源码

word2vec使用说明及源码介绍 1.下载地址 2.中文语料 3.参数介绍 4.计算相似词语 5.三个词预测语义语法关系 6.关键词聚类 -train Result_Country.txt 表示的是...

GDAL源码剖析(七)之GDAL RasterIO使用说明

一、关于RasterIO 在GDAL中读写图像是最基本的操作,那么RasterIO也就是最基本的函数了,关于RasterIO有很多方式,这个函数的功能相当强大,下面慢慢说明。RasterIO一共...

GDAL源码剖析(十二)之GDAL Warp API使用说明

一、简介 本文原文地址:http://www.gdal.org/warptut.html GDAL Warp API(在文件gdalwarper.h中定义)是一个高效的进行图像变换的接口。主要由几...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:boost.tuple源码整理和使用说明
举报原因:
原因补充:

(最多只允许输入30个字)