generics.h

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

		{	// 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(ConstReverseRandomAccessIterator% _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(ConstReverseRandomAccessIterator% _Right)
		{	// test if *this < _Right, class specific
		return (!_Myiter->less_than(_Right));
		}

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

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

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

	ConstReverseRandomAccessIterator operator++(int)
		{	// return incremented
		ConstReverseRandomAccessIterator _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));
		}

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

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

		--*this;
		return (_Iter);
		}

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

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

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

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

	ConstReverseRandomAccessIterator operator-(difference_type _Right)
		{	// return decremented by integer
		ConstReverseRandomAccessIterator _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 const_reference default[difference_type]
		{	// get subscripted element
		const_reference get(difference_type _Pos)
			{	// get _Pos element
			ConstReverseRandomAccessIterator _Where = *this + _Pos;

			return (_Where.get_cref());
			}
		};

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

//
// GENERIC REF CLASS ContainerBidirectionalIterator
//
generic<typename TValue>
	public ref class ContainerBidirectionalIterator
	:	public Generic::IBidirectionalIterator<TValue>
	{	// iterator for mutable bidirectional container
public:
	// types
	typedef ContainerBidirectionalIterator<TValue> _Mytype_t;
	typedef Generic::IBidirectionalIterator<TValue> _Myiter_t;
	typedef Generic::IBidirectionalContainer<TValue> TCont;
	typedef INode<TValue> _Mynode_it;

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

	// basics
	ContainerBidirectionalIterator()
		:	_Mynode(nullptr)
		{	// construct default
		}

	ContainerBidirectionalIterator(ContainerBidirectionalIterator% _Right)
		:	_Mynode(_Right._Mynode)
		{	// construct by copying an iterator
		}

	ContainerBidirectionalIterator% operator=(
		ContainerBidirectionalIterator% _Right)
		{	// assign an iterator
		_Mynode = _Right._Mynode;
		return (*this);
		}

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

	// constructors
	ContainerBidirectionalIterator(_Mynode_it^ _Node)
		:	_Mynode(_Node)
		{	// construct from node
		}

	// member functions
	virtual System::Object^ Clone()
		{	// return a copy
		return (gcnew ContainerBidirectionalIterator(_Mynode));
		}

	virtual int get_bias()
		{	// get offset from wrapped iterator
		return (0);
		}

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

	virtual bool valid()
		{	// test if iterator valid
		return (_Mynode != nullptr && _Mynode->container() != nullptr);
		}

	virtual System::Object^ container()
		{	// return owning container
		return (_Mynode == nullptr ? nullptr : _Mynode->container());
		}

	virtual void next()
		{	// increment
		_Mynode = _Mynode->next_node();
		}

	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(ContainerBidirectionalIterator% _Right)
		{	// test if *this == _Right, class specific
		if (container() == nullptr
			|| container() != _Right.container())
			throw gcnew System::ArgumentException();
		return (_Mynode == _Right._Mynode);
		}

	virtual const_reference get_cref()
		{	// return const reference to designated element
		return (_Mynode->_Value);
		}

	virtual reference get_ref()
		{	// return reference to designated element
		return (_Mynode->_Value);
		}

	virtual void prev()
		{	// decrement
		_Mynode = _Mynode->prev_node();
		}

//	difference_type move(difference_type _Offset);
//	difference_type distance(
//		Generic::IRandomAccessIterator<TValue>^ _Right);
//	bool less_than(Generic::IRandomAccessIterator<TValue>^ _Right);

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

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

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

	ContainerBidirectionalIterator operator++(int)
		{	// return incremented
		ContainerBidirectionalIterator _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));
		}

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

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

		--*this;
		return (_Iter);
		}

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

_STLCLR_FIELD_ACCESS:
	// data members
	_Mynode_it^ _Mynode;	// node into list
	};

//
// GENERIC REF CLASS ConstContainerBidirectionalIterator
//
generic<typename TValue>
	public ref class ConstContainerBidirectionalIterator
	:	public Generic::IBidirectionalIterator<TValue>
	{	// iterator for nonmutable bidirectional container
public:
	// types
	typedef ConstContainerBidirectionalIterator<TValue> _Mytype_t;
	typedef Generic::IBidirectionalIterator<TValue> _Myiter_t;
	typedef Generic::IBidirectionalContainer<TValue> TCont;
	typedef INode<TValue> _Mynode_it;

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

	// basics
	ConstContainerBidirectionalIterator()
		:	_Mynode(nullptr)
		{	// construct default
		}

	ConstContainerBidirectionalIterator(
		ConstContainerBidirectionalIterator% _Right)
		:	_Mynode(_Right._Mynode)
		{	// construct by copying an iterator
		}

	ConstContainerBidirectionalIterator% operator=(
		ConstContainerBidirectionalIterator% _Right)
		{	// assign an iterator
		_Mynode = _Right._Mynode;
		return (*this);
		}

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

	// constructors and special members
	ConstContainerBidirectionalIterator(_Mynode_it^ _Node)
		:	_Mynode(_Node)
		{	// construct from node
		}

	ConstContainerBidirectionalIterator(
		Generic::ContainerBidirectionalIterator<TValue>% _Right)
		:	_Mynode((_Mynode_it^)_Right.get_node())
		{	// construct from mutable iterator
		}

	ConstContainerBidirectionalIterator% operator=(
		Generic::ContainerBidirectionalIterator<TValue>% _Right)
		{	// assign from mutable iterator
		_Mynode = (_Mynode_it^)_Right.get_node();
		return (*this);
		}

	// member functions
	virtual System::Object^ Clone()
		{	// return a copy
		return (gcnew ConstContainerBidirectionalIterator(_Mynode));
		}

	virtual int get_bias()
		{	// get offset from wrapped iterator
		return (0);
		}

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

	virtual bool valid()
		{	// test if iterator valid
		return (container() != nullptr);
		}

	virtual System::Object^ container()
		{	// return owning container
		return (_Mynode == nullptr ? nullptr : _Mynode->container());
		}

	virtual void next()
		{	// increment
		_Mynode = _Mynode->next_node();
		}

	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(ConstContainerBidirectionalIterator% _Right)
		{	// test if *this == _Right, class specific
		if (container() == nullptr
			|| container() != _Right.container())
			throw gcnew System::ArgumentException();
		return (_Mynode == _Right._Mynode);
		}

	virtual const_reference get_cref()
		{	// return const reference to designated element
		return (_Mynode->_Value);
		}

	virtual reference get_ref()
		{	// return reference to designated element
#pragma warning(push)
#pragma warning(disable: 4715)
		throw gcnew System::InvalidOperationException();
#pragma warning(pop)
		}

	virtual void prev()
		{	// decrement
		_Mynode = _Mynode->prev_node();
		}

//	difference_type move(difference_type _Offset);
//	difference_type distance(
//		Generic::IRandomAccessIterator<TValue>^ _Right);
//	bool less_than(Generic::IRandomAccessIterator<TValue>^ _Right);

	// operators
	[System::Diagnostics::CodeAnalysis::SuppressMessage("Microsoft.Design", "CA1000")]