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

最新推荐文章于 2022-07-12 20:00:13 发布

laibach0304

最新推荐文章于 2022-07-12 20:00:13 发布

阅读量765

点赞数

分类专栏： C++ 文章标签： class access null struct reference tuples

本文链接：https://blog.csdn.net/laibach0304/article/details/1814498

版权

C++ 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

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

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

struct null_type{};

//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

//来获得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<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<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

//用来侦测你是否使用了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

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

template <class T> class non_storeable_type

{

non_storeable_type();

};

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返回

//tail是cons的一个数据成员

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

//将tuple和cons建立了映射关系

//递归的将一系列的类型定义为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函数更短，使用的一个小技巧,所有的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_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的第一个模版参数是返回类型，non－const的get返回non－const类型对象

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

HT,

>(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

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

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;//第二个数据成员

//const和non-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&)

: 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

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函数,产生一个临时的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 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

laibach0304

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
boost.tuple源码整理和使用说明

IntroductionA 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 e
复制链接

扫一扫

专栏目录