generics.h

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

		ConstReverseBidirectionalIterator% _Left)
		{	// return const reference to designated element
		return (_Left.get_cref());
		}

	ConstReverseBidirectionalIterator operator++()
		{	// return incremented
		next();
		return (*this);
		}

	ConstReverseBidirectionalIterator operator++(int)
		{	// return incremented
		ConstReverseBidirectionalIterator _Iter = *this;

		++*this;
		return (_Iter);
		}

	bool operator==(Generic::IInputIterator<TValue>^ _Right)
		{	// test if *this == _Right
		return (equal_to(_Right));
		}

	bool operator==(_Mytype_t% _Right)
		{	// test if *this == _Right
		return (equal_to(_Right));
		}

	bool operator!=(Generic::IInputIterator<TValue>^ _Right)
		{	// test if *this != _Right
		return (!(*this == _Right));
		}

	bool operator!=(_Mytype_t% _Right)
		{	// test if *this != _Right
		return (!(*this == _Right));
		}

	ConstReverseBidirectionalIterator operator--()
		{	// return decremented
		prev();
		return (*this);
		}

	ConstReverseBidirectionalIterator operator--(int)
		{	// return decremented
		ConstReverseBidirectionalIterator _Iter = *this;

		--*this;
		return (_Iter);
		}

//	ConstReverseBidirectionalIterator^ operator+(difference_type _Right);
//	static ConstReverseBidirectionalIterator^
//		operator+(difference_type _Left,
//			ConstReverseBidirectionalIterator _Right);
//	ConstReverseBidirectionalIterator^ operator-(difference_type _Right);
//	difference_type operator-(ConstReverseBidirectionalIterator^ _Right);
//	bool operator<(ConstReverseBidirectionalIterator^ _Right);
//	bool operator>=(ConstReverseBidirectionalIterator^ _Right);
//	bool operator>(ConstReverseBidirectionalIterator^ _Right);
//	bool operator<=(ConstReverseBidirectionalIterator^ _Right);

_STLCLR_FIELD_ACCESS:
	_Myiter_t^ _Myiter;	// wrapped iterator
	};

//
// GENERIC REF CLASS ReverseRandomAccessIterator
//
generic<typename TValue>
	public ref class ReverseRandomAccessIterator
	:	public Generic::IRandomAccessIterator<TValue>
	{	// mutable reverse random_access iterator, generic
public:
	// types
	typedef ReverseRandomAccessIterator<TValue> _Mytype_t;
	typedef Generic::IRandomAccessIterator<TValue> _Myiter_t;

	typedef TValue value_type;
	typedef int difference_type;
	typedef value_type% pointer;
	typedef value_type% reference;
	typedef value_type% const_reference;

	// basics
	ReverseRandomAccessIterator()
		:	_Myiter(nullptr)
		{	// construct default
		}

	ReverseRandomAccessIterator(ReverseRandomAccessIterator% _Right)
		:	_Myiter((_Myiter_t^)_Right._Myiter->Clone())
		{	// construct by copying an iterator
		}

	ReverseRandomAccessIterator% operator=(
		ReverseRandomAccessIterator% _Right)
		{	// assign an iterator
		if ((Object^)this != %_Right)
			_Myiter = (_Myiter_t^)_Right._Myiter->Clone();
		return (*this);
		}

	operator _Myiter_t^()
		{	// convert to interface
		return (this);
		}

	// constructors and special member functions
	ReverseRandomAccessIterator(_Myiter_t^ _Iter)
		:	_Myiter((_Myiter_t^)_Iter->Clone())
		{	// construct from wrapped iterator
		}

	_Myiter_t^ base()
		{	// get underlying base iterator
		return (_Myiter);
		}

	// member functions
	virtual System::Object^ Clone()
		{	// return a copy
		return (gcnew ReverseRandomAccessIterator(
			(_Myiter_t^)_Myiter->Clone()));
		}

	virtual int get_bias()
		{	// get offset from wrapped iterator
		return (_Myiter->get_bias());
		}

	virtual System::Object^ get_node()
		{	// get node from wrapped iterator
		return (nullptr);
		}

	virtual bool valid()
		{	// test if wrapped iterator valid
		return (_Myiter->valid());
		}

	virtual System::Object^ container()
		{	// return container for wrapped iterator
		return (_Myiter->container());
		}

	virtual void next()
		{	// decrement wrapped iterator
		_Myiter->prev();
		}

	virtual bool equal_to(Generic::IInputIterator<TValue>^ _Right)
		{	// test if *this == _Right
		if (container() == nullptr
			|| container() != _Right->container())
			throw gcnew System::ArgumentException();
		return (get_bias() == _Right->get_bias()
			&& get_node() == _Right->get_node());
		}

	bool equal_to(ReverseRandomAccessIterator% _Right)
		{	// test if wrapped iterators are equal, class specific
		return (_Myiter->equal_to(_Right._Myiter));
		}

	virtual const_reference get_cref()
		{	// return const reference from wrapped iterator
		_Myiter->prev();
		const_reference _Ref = _Myiter->get_cref();
		_Myiter->next();
		return (_Ref);
		}

	virtual reference get_ref()
		{	// return reference from wrapped iterator
		_Myiter->prev();
		reference _Ref = _Myiter->get_ref();
		_Myiter->next();
		return (_Ref);
		}

	virtual void prev()
		{	// increment wrapped iterator
		_Myiter->next();
		}

	virtual difference_type move(difference_type _Offset)
		{	// incremented by integer
		return (_Myiter->move(-_Offset));	// can overflow
		}

	virtual difference_type distance(
		Generic::IRandomAccessIterator<TValue>^ _Right)
		{	// return difference of two iterators
		if (container() == nullptr
			|| container() != _Right->container())
			throw gcnew System::ArgumentException();
		return (_Right->get_bias() - get_bias());
		}

	difference_type distance(ReverseRandomAccessIterator% _Right)
		{	// return difference of two iterators, class specific
		return (_Myiter->distance(_Right._Myiter));
		}

	virtual bool less_than(Generic::IRandomAccessIterator<TValue>^ _Right)
		{	// test if *this < _Right
		if (container() == nullptr
			|| container() != _Right->container())
			throw gcnew System::ArgumentException();
		return (!(get_bias() < _Right->get_bias()));
		}

	bool less_than(ReverseRandomAccessIterator% _Right)
		{	// test if *this < _Right, class specific
		return (!_Myiter->less_than(_Right));
		}

	// operators
	[System::Diagnostics::CodeAnalysis::SuppressMessage("Microsoft.Design", "CA1000")]
	static reference operator->(ReverseRandomAccessIterator% _Left)
		{	// return pointer to class object
		return (_Left.get_ref());
		}

	[System::Diagnostics::CodeAnalysis::SuppressMessage("Microsoft.Design", "CA1000")]
	static reference operator*(ReverseRandomAccessIterator% _Left)
		{	// return reference to designated element
		return (_Left.get_ref());
		}

	ReverseRandomAccessIterator operator++()
		{	// return incremented
		next();
		return (*this);
		}

	ReverseRandomAccessIterator operator++(int)
		{	// return incremented
		ReverseRandomAccessIterator _Iter = *this;

		++*this;
		return (_Iter);
		}

//	bool operator==(Generic::IInputIterator<TValue>^ _Right);

	bool operator==(_Mytype_t% _Right)
		{	// test if *this == _Right
		return (equal_to(_Right));
		}

//	bool operator!=(Generic::IInputIterator<TValue>^ _Right);

	bool operator!=(_Mytype_t% _Right)
		{	// test if *this != _Right
		return (!(*this == _Right));
		}

	ReverseRandomAccessIterator operator--()
		{	// return decremented
		prev();
		return (*this);
		}

	ReverseRandomAccessIterator operator--(int)
		{	// return decremented
		ReverseRandomAccessIterator _Iter = *this;

		--*this;
		return (_Iter);
		}

	ReverseRandomAccessIterator operator+(difference_type _Right)
		{	// return incremented by integer
		ReverseRandomAccessIterator _Iter = *this;

		_Iter.move(_Right);
		return (_Iter);
		}

	[System::Diagnostics::CodeAnalysis::SuppressMessage("Microsoft.Design", "CA1000")]
	static ReverseRandomAccessIterator operator+(difference_type _Left,
		ReverseRandomAccessIterator% _Right)
		{	// return incremented by integer
		ReverseRandomAccessIterator _Iter = _Right;

		_Iter.move(_Left);
		return (_Iter);
		}

	ReverseRandomAccessIterator operator-(difference_type _Right)
		{	// return decremented by integer
		ReverseRandomAccessIterator _Iter = *this;

		_Iter.move(-_Right);	// can overflow
		return (_Iter);
		}

	difference_type operator-(
		Generic::IRandomAccessIterator<TValue>^ _Right)
		{	// return difference of two iterators
		return (distance(_Right));
		}

//	bool operator<(Generic::IRandomAccessIterator<TValue>^ _Right);

	bool operator<(_Mytype_t% _Right)
		{	// test if *this < _Right
		return (less_than(_Right));
		}

//	bool operator>=(Generic::IRandomAccessIterator<TValue>^ _Right);

	bool operator>=(_Mytype_t% _Right)
		{	// test if *this >= _Right
		return (!(*this < _Right));
		}

//	bool operator>(Generic::IRandomAccessIterator<TValue>^ _Right);

	bool operator>(_Mytype_t% _Right)
		{	// test if *this > _Right
		return (_Right < *this);
		}

//	bool operator<=(Generic::IRandomAccessIterator<TValue>^ _Right);

	bool operator<=(_Mytype_t% _Right)
		{	// test if *this <= _Right
		return (!(_Right < *this));
		}

	property value_type default[difference_type]
		{	// get or set subscripted element
		value_type get(difference_type _Pos)
			{	// get _Pos element
			ReverseRandomAccessIterator _Where = *this + _Pos;

			return (_Where.get_ref());
			}

		void set(difference_type _Pos, value_type _Val)
			{	// set _Pos element
			ReverseRandomAccessIterator _Where = *this + _Pos;

			_Where.get_ref() = _Val;
			}
		};

_STLCLR_FIELD_ACCESS:
	_Myiter_t^ _Myiter;	// wrapped iterator
	};

//
// GENERIC REF CLASS ConstReverseRandomAccessIterator
//
generic<typename TValue>
	public ref class ConstReverseRandomAccessIterator
	:	public Generic::IRandomAccessIterator<TValue>
	{	// nonmutable reverse random_access iterator, generic
public:
	// types
	typedef ConstReverseRandomAccessIterator<TValue> _Mytype_t;
	typedef Generic::IRandomAccessIterator<TValue> _Myiter_t;

	typedef TValue value_type;
	typedef int difference_type;
	typedef value_type% pointer;
	typedef value_type% reference;
	typedef value_type% const_reference;

	// basics
	ConstReverseRandomAccessIterator()
		:	_Myiter(nullptr)
		{	// construct default
		}

	ConstReverseRandomAccessIterator(
		ConstReverseRandomAccessIterator% _Right)
		:	_Myiter((_Myiter_t^)_Right._Myiter->Clone())
		{	// construct by copying an iterator
		}

	ConstReverseRandomAccessIterator% operator=(
		ConstReverseRandomAccessIterator% _Right)
		{	// assign an iterator
		if ((Object^)this != %_Right)
			_Myiter = (_Myiter_t^)_Right._Myiter->Clone();
		return (*this);
		}

	operator _Myiter_t^()
		{	// convert to interface
		return (this);
		}

	// constructors and special member functions
	ConstReverseRandomAccessIterator(_Myiter_t^ _Iter)
		:	_Myiter((_Myiter_t^)_Iter->Clone())
		{	// construct from wrapped iterator
		}

	ConstReverseRandomAccessIterator(
		ReverseRandomAccessIterator<TValue>% _Iter)
		:	_Myiter((_Myiter_t^)_Iter.base()->Clone())
		{	// construct from mutable iterator
		}

	ConstReverseRandomAccessIterator% operator=(
		ReverseRandomAccessIterator<TValue>% _Right)
		{	// assign from mutable iterator
		_Myiter = (_Myiter_t^)_Right.base()->Clone();
		return (*this);
		}

	_Myiter_t^ base()
		{	// get underlying base iterator
		return (_Myiter);
		}

	// member functions
	virtual System::Object^ Clone()
		{	// return a copy
		return (gcnew ConstReverseRandomAccessIterator(
			(_Myiter_t^)_Myiter->Clone()));
		}

	virtual int get_bias()
		{	// get offset from wrapped iterator
		return (_Myiter->get_bias());
		}

	virtual System::Object^ get_node()
		{	// get node from wrapped iterator
		return (nullptr);
		}

	virtual bool valid()
		{	// test if wrapped iterator valid
		return (_Myiter->valid());
		}

	virtual System::Object^ container()
		{	// return container for wrapped iterator
		return (_Myiter->container());
		}

	virtual void next()
		{	// decrement wrapped iterator
		_Myiter->prev();
		}

	virtual bool equal_to(Generic::IInputIterator<TValue>^ _Right)
		{	// test if *this == _Right
		if (container() == nullptr
			|| container() != _Right->container())
			throw gcnew System::ArgumentException();
		return (get_bias() == _Right->get_bias()
			&& get_node() == _Right->get_node());
		}

	bool equal_to(ConstReverseRandomAccessIterator% _Right)
		{	// test if wrapped iterators are equal, class specific
		return (_Myiter->equal_to(_Right._Myiter));
		}

	virtual const_reference get_cref()
		{	// return const reference from wrapped iterator
		_Myiter->prev();
		const_reference _Ref = _Myiter->get_cref();
		_Myiter->next();
		return (_Ref);
		}

	virtual reference get_ref()
		{	// return reference from wrapped iterator
#pragma warning(push)
#pragma warning(disable: 4715)
		throw gcnew System::InvalidOperationException();
#pragma warning(pop)
		}

	virtual void prev()
		{	// increment wrapped iterator
		_Myiter->next();
		}

	virtual difference_type move(difference_type _Offset)