tuple

C语言库函数的原型,有用的拿去

// tuple TR1 header
#pragma once
#ifndef _TUPLE_
#define _TUPLE_
#ifndef RC_INVOKED
#include <type_traits>
#include <xutility>
#include <xrefwrap>

 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)

 #pragma warning(disable: 4522)

_STD_BEGIN
namespace tr1 {	// TR1 additions
	// TEMPLATE STRUCT _Arg_traits
template<class _Ty>
	struct _Arg_traits
	{	// template that transforms argument types
	typedef const _Ty& _CType;
	typedef _Ty& _RType;
	typedef const _Ty& _AType;
	typedef _Ty _VType;
	typedef _Ty _BType;
	};

template<class _Ty>
	struct _Arg_traits<_Ty&>
	{	// template specialization for arguments passed by reference
	typedef _Ty& _CType;
	typedef _Ty& _RType;
	typedef _Ty& _AType;
	typedef _Ty& _VType;
	typedef _Ty _BType;
	};

template<class _Ty>
	struct _Arg_traits<const reference_wrapper<_Ty>&>
	{	// template specialization for reference_wrapper arguments
	typedef const _Ty& _CType;
	typedef _Ty& _RType;
	typedef _Ty& _AType;
	typedef _Ty& _VType;
	typedef _Ty _BType;
	};

	// TEMPLATE FUNCTION _Assign

template<class _Tgt,
	class _Src> inline
	void _Assign(_Tgt& _Tx, _Src&& _Sx)
	{	// assign _Sx to _Tx
	_Tx = _STD forward<_Src>(_Sx);
	}

template<class _Tgt,
	class _Src> inline
	void _Assign(reference_wrapper<_Tgt> _Tx, _Src&& _Sx)
	{	// assign _Sx to _Tx.get()
	_Tx.get() = _STD forward<_Src>(_Sx);
	}

	// TEMPLATE STRUCT _Cons_node
template<class _Car,
	class _Cdr>
	struct _Cons_node
	{	// node for type list
	typedef typename _Arg_traits<_Car>::_VType _Value_type;
	typedef _Cdr _Tail_type;

	_Cons_node()
		: _Value(), _Tail()
		{	// construct
		}

	_Cons_node(const _Cons_node& _Right)
		: _Value(_Right._Value), _Tail(_Right._Tail)
		{	// construct
		}

	template<class _Car1,
		class _Cdr1>
		_Cons_node(const _Cons_node<_Car1, _Cdr1>& _Right)
			: _Value(_Right._Value), _Tail(_Right._Tail)
		{	// construct
		}

	template<_CLASS_FARG0_MAX>
		_Cons_node(_FARG0_F0_CREFIFY_MAX)
			: _Value(_Fx0), _Tail(_F1_F2_MAX, _Nil_obj)
		{	// construct
		}

	_Cons_node& operator=(const _Cons_node& _Right)
		{	// assign
		_Assign(_Value, _Right._Value);
		_Tail = _Right._Tail;
		return (*this);
		}

	template<class _Car1,
		class _Cdr1>
		_Cons_node& operator=(const _Cons_node<_Car1, _Cdr1>& _Right)
		{	// copy _Right to *this
		_Assign(_Value, _Right._Value);
		_Tail = _Right._Tail;
		return (*this);
		}

	void swap(_Cons_node& _Right)
		{	// swap elements
		_Swap_adl(_Value, _Right._Value);
		_Tail.swap(_Right._Tail);
		}

	_Cons_node(_Cons_node&& _Right)
		: _Value(_STD forward<_Value_type>(_Right._Value)),
			_Tail(_STD forward<_Tail_type>(_Right._Tail))
		{	// construct
		}

	template<_CLASS_FARG0_MAX>
		_Cons_node(_FARG0_F0_REFREF_MAX)
		: _Value(_STD forward<_Farg0>(_Fx0)),
			_Tail(_F1_F2_FWD_MAX, _Nil_obj)
		{	// construct
		}

	template<class _Car1,
		class _Cdr1>
		_Cons_node(_Cons_node<_Car1, _Cdr1>&& _Right)
			: _Value(_STD forward<typename _Cons_node<_Car1, _Cdr1>
				::_Value_type>(_Right._Value)),
				_Tail(_STD forward<typename _Cons_node<_Car1, _Cdr1>
					::_Tail_type>(_Right._Tail))
		{	// construct
		}

	template<class _Car1,
		class _Cdr1>
		_Cons_node& operator=(_Cons_node<_Car1, _Cdr1>&& _Right)
		{	// assign
		_Assign(_Value,
			_STD forward<typename _Cons_node<_Car1, _Cdr1>::_Value_type>
				(_Right._Value));
		_Tail =
			_STD forward<typename _Cons_node<_Car1, _Cdr1>::_Tail_type>
				(_Right._Tail);
		return (*this);
		}

	template<class _Car1,
		class _Cdr1>
		bool _Eq(const _Cons_node<_Car1, _Cdr1>& _Right) const
		{	// return true if *this == _Right
		return (_Value == _Right._Value
			&& _Tail._Eq(_Right._Tail));
		}

	template<class _Car1,
		class _Cdr1>
		bool _Lt(const _Cons_node<_Car1, _Cdr1>& _Right) const
		{	// return true if *this < _Right
		return (_Value < _Right._Value ? true
			: _Right._Value < _Value ? false
			: _Tail._Lt(_Right._Tail));
		}

	_Value_type _Value;
	_Tail_type _Tail;
	};

template<>
	struct _Cons_node<_Nil, _Nil>
	{	// node for end of list
	typedef _Nil _Value_type;
	typedef _Nil _Tail_type;

	_Cons_node()
		{	// construct
		}

	_Cons_node(const _Cons_node&)
		{	// construct
		}

	template<class _Car1,
		class _Cdr1>
		_Cons_node(const _Cons_node<_Car1, _Cdr1>&)
		{	// construct
		}

	_Cons_node(_NIL_TAIL_MAX)
		{	// construct
		}

	_Cons_node& operator=(const _Cons_node&)
		{	// assign
		return (*this);
		}

	template<class _Car1,
		class _Cdr1>
		_Cons_node& operator=(const _Cons_node<_Car1, _Cdr1>&)
		{	// assign
		return (*this);
		}

	void swap(_Cons_node&)
		{	// swap
		}

	_Cons_node(_Cons_node&&)
		{	// construct
		}

	template<class _Car1,
		class _Cdr1>
		_Cons_node(_Cons_node<_Car1, _Cdr1>&&)
		{	// construct
		}

	template<_CLASS_FARG0_MAX>
		_Cons_node(_FARG0_F0_REFREF_MAX)
		{	// construct
		}

	_Cons_node& operator=(_Cons_node&&)
		{	// assign
		return (*this);
		}

	template<class _Car1,
		class _Cdr1>
		_Cons_node& operator=(_Cons_node<_Car1, _Cdr1>&&)
		{	// assign
		return (*this);
		}

	bool _Eq(const _Cons_node&) const
		{	// compare
		return (true);
		}

	bool _Lt(const _Cons_node&) const
		{	// compare
		return (false);
		}

	_Value_type _Value;
	_Tail_type _Tail;
	};

	// TEMPLATE STRUCT _Get
template<size_t _Idx,
	class _Node>
	struct _Get
	{	// struct that determines type and value of element at _Idx
	typedef _Get<_Idx - 1, typename _Node::_Tail_type> _Get0;
	typedef typename _Get0::_Type _Type;

	static typename _Arg_traits<_Type>::_RType _Val(_Node& _Nx)
		{	// return value
		return (_Get0::_Val(_Nx._Tail));
		}

	static typename _Arg_traits<_Type>::_CType _Val(const _Node& _Nx)
		{	// return value
		return (_Get0::_Val(_Nx._Tail));
		}
	};

template<class _Ty>
	struct _Not_nil
	{	// defined only if _Ty is not _Nil
	};

template<>
	struct _Not_nil<_Nil>;

template<class _Node>
	struct _Get<0, _Node>
		: public _Not_nil<typename _Node::_Value_type>
	{	// struct that determines type and value of element at index 0
	typedef typename _Node::_Value_type _Type;

	static typename _Arg_traits<_Type>::_RType _Val(_Node& _Nx)
		{	// return value
		return (_Nx._Value);
		}

	static typename _Arg_traits<_Type>::_CType _Val(const _Node& _Nx)
		{	// return value
		return (_Nx._Value);
		}
	};

	// TEMPLATE STRUCT _Size
template<class _Node>
	struct _Size
	{	// struct that determines number of elements in type list
	static const size_t _Value =
		1 + _Size<typename _Node::_Tail_type>::_Value;
	};

template<>
	struct _Size<_Cons_node<_Nil, _Nil> >
	{	// struct that determines number of elements in empty type list
	static const size_t _Value = 0;
	};

	// TEMPLATE STRUCT _Tuple_type
template<class _Arg0,
	_CDR15_MAX(class _Arg, = _Nil)>
	struct _Tuple_type
	{	// struct to determine type for a tuple's implementation
	typedef _Cons_node<_Arg0,
		typename _Tuple_type<_ARG1_ARG2_MAX, _Nil>::_Type> _Type;
	};

template<>
	struct _Tuple_type<_NIL_TAIL_MAX>
	{	// struct to determine type for an empty tuple
	typedef _Cons_node<_Nil, _Nil> _Type;
	};

	// TEMPLATE STRUCT tuple
template<_CLASS_ARG0_DEF_MAX>
	class tuple
	{	// class that holds objects of various types
public:
	typedef tuple<_ARG0_ARG1_MAX> _Myt;
	typedef typename _Tuple_type<_ARG0_ARG1_MAX>::_Type _MyImpl;

	tuple()
		: _Impl()
		{	// construct
		}

	tuple(const _Myt& _Right)
		: _Impl(_Right._Impl)
		{	// construct copy of _Right
		}

	template<_CLASS_FARG0_MAX>
		tuple(const tuple<_FARG0_FARG1_MAX>& _Right)
		: _Impl(_Right._Impl)
		{	// construct copy of _Right
		}

	template<class _Farg0,
		class _Farg1>
		tuple(const pair<_Farg0, _Farg1>& _Right)
		: _Impl(_Right.first, _Right.second, _TAIL_2(_Nil_obj))
		{	// construct copy of _Right
		}

	// construct from one or more arguments
#define _INCL_FILE_xxtuple0
#include <xfwrap>