vector

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

		{	// erase all
		erase_n(0, size());
		}

	void swap(_Mytype_t% _Right)
		{	// exchange contents with _Right
		if ((Object^)this != %_Right)
			{	// worth doing, swap
			_Myarray_t^ _Tarray = _Myarray;
			size_type _Tsize = _Mysize;

			_Myarray = _Right._Myarray;
			_Right._Myarray = _Tarray;

			_Mysize = _Right._Mysize;
			_Right._Mysize = _Tsize;

			++_Mygen;
			++_Right._Mygen;
			}
		}

_STLCLR_FIELD_ACCESS:
	size_type _Buy(size_type _Capacity)
		{	// allocate array with _Capacity elements
		_Mygen = 0;
		if (_Capacity < 0)
			throw gcnew System::ArgumentOutOfRangeException();

		if (0 < _Capacity)
			_Myarray = gcnew _Myarray_t(_Capacity);
		return (_Capacity);
		}

	size_type _Copy(_Myarray_t^ _Source,
		size_type _First, size_type _Last, size_type _Dest)
		{	// copy [_First, _Last) in _Source to _Dest
		for (; _First != _Last; ++_First, ++_Dest)
			_Myarray[_Dest] = _Source[_First];
		return (_Dest);
		}

	void _Copyback(size_type _First, size_type _Last, size_type _Dest)
		{	// copy [_First, _Last) to [..., _Dest)
		for (; _First != _Last; )
			_Myarray[--_Dest] = _Myarray[--_Last];
		}

	size_type _Fill_n(size_type _First, size_type _Count, value_type _Val)
		{	// copy initializing _Count * _Val
		for (; 0 < _Count; --_Count, ++_First)
			_Myarray[_First] = _Mymake_t::make_value(_Val);
		return (_First);
		}

	size_type _Insert_space(size_type _Where, size_type _Count)
		{	// dig a hole for _Count elements at _Where
		size_type _Capacity = capacity();

		if (_Where < 0 || size() < _Where
			|| _Count < 0 || _Maxsize - size() < _Count)
			throw gcnew System::ArgumentOutOfRangeException();
		else if (_Capacity < size() + _Count)
			{	// not enough room, reallocate
			_Myarray_t^ _Oldarray = _Myarray;

			_Capacity = _Maxsize - _Capacity < _Capacity
				? 0 : 2 * _Capacity;	// try to double capacity
			if (_Capacity < size() + _Count)
				_Capacity = size() + _Count;
			_Myarray = gcnew _Myarray_t(_Capacity);

			_Copy(_Oldarray, 0, _Where, 0);
			_Mysize = _Copy(_Oldarray, _Where, _Mysize, _Where + _Count);
			}
		else if (size() - _Where < _Count)
			_Mysize = _Copy(_Myarray, _Where, size(),
				_Where + _Count);	// new stuff spills off end
		else
			{	// new stuff can all be assigned
			size_type _Oldend = size();

			_Mysize = _Copy(_Myarray, _Oldend - _Count, _Oldend, _Oldend);
			_Copyback(_Where, _Oldend - _Count, _Oldend);
			}
		return (_Where);
		}

	// data members
	_Myarray_t^ _Myarray;	// managed array of _Value_t
	size_type _Mysize;		// number of active elements
	unsigned long _Mygen;	// current change generation

	// interfaces
public:
	virtual System::Object^ Clone()
		{	// clone the vector
		return (gcnew vector_impl(*this));
		}

private:
	property size_type Count
		{	// element count
		virtual size_type get() sealed
			= System::Collections::ICollection::Count::get
			{	// get element count
			return (size());
			}
		};

	property bool IsSynchronized
		{	// synchronized status
		virtual bool get() sealed
			= System::Collections::ICollection::IsSynchronized::get
			{	// test if synchronized
			return (false);
			}
		};

	property System::Object^ SyncRoot
		{	// synchronizer
		virtual System::Object^ get() sealed
			= System::Collections::ICollection::SyncRoot::get
			{	// get synchronizer
			return (this);
			}
		};

	virtual void CopyTo(System::Array^ _Dest_arg, int _First) sealed
		= System::Collections::ICollection::CopyTo
		{	// copy to _Dest_arg, beginning at _First
		cli::array<System::Object^>^ _Dest =
			(cli::array<System::Object ^>^)_Dest_arg;
		for (int _Idx = size(); 0 <= --_Idx; )
			{	// copy back to front
			_Dest[_First + _Idx] = at(_Idx);
			}
		}

	virtual System::Collections::IEnumerator^ GetEnumerator() sealed
		= System::Collections::IEnumerable::GetEnumerator
		{	// get enumerator for the container
		return (gcnew _STLCLR VectorEnumerator<_Value_t>(this, 0));
		}

	virtual unsigned long get_generation_virtual() sealed
		= _Mycont_it::get_generation
		{	// get underlying container generation
		return (get_generation());
		}

	virtual bool valid_bias_virtual(size_type _Bias) sealed
		= _Mycont_it::valid_bias
		{	// test if _Bias is currently a valid bias
		return (valid_bias(_Bias));
		}

	virtual reference at_virtual(size_type _Pos) sealed
		= _Mycont_it::at
		{	// subscript mutable sequence with checking
		return (at(_Pos));
		}

	virtual reference at_bias_virtual(size_type _Bias) sealed
		= _Mycont_it::at_bias
		{	// subscript mutable sequence with checking, biased
		return (at_bias(_Bias));
		}

	virtual reference front_virtual() sealed
		= _Mycont_it::front
		{	// get first element of mutable sequence
		return (front());
		}

	virtual reference back_virtual() sealed
		= _Mycont_it::back
		{	// get last element of mutable sequence
		return (back());
		}

	// iterator generators
	virtual generic_iterator begin_virtual() sealed
		= _Mycont_it::begin
		{	// return iterator for beginning of mutable sequence
		return (begin());
		}
	virtual generic_iterator end_virtual() sealed
		= _Mycont_it::end
		{	// return iterator for end of mutable sequence
		return (end());
		}

	virtual generic_reverse_iterator rbegin_virtual() sealed
		= _Mycont_it::rbegin
		{	// return reverse iterator for beginning of mutable sequence
		return (generic_reverse_iterator(end()));
		}

	virtual generic_reverse_iterator rend_virtual() sealed
		= _Mycont_it::rend
		{	// return reverse iterator for end of mutable sequence
		return (generic_reverse_iterator(begin()));
		}

	// size controllers
	virtual void reserve_virtual(size_type _Capacity) sealed
		= _Mycont_it::reserve
		{	// determine new minimum length of allocated storage
		reserve(_Capacity);
		}

	virtual size_type capacity_virtual() sealed
		= _Mycont_it::capacity
		{	// return current length of allocated storage
		return (capacity());
		}

	virtual void resize_virtual(size_type _Newsize) sealed
		= _Mycont_it::resize
		{	// determine new length, padding with value_type elements
		resize(_Newsize);
		}

	virtual void resize_virtual(size_type _Newsize, value_type _Val) sealed
		= _Mycont_it::resize
		{	// determine new length, padding with _Val elements
		resize(_Newsize, _Val);
		}

	virtual size_type size_virtual() sealed
		= _Mycont_it::size
		{	// return length of sequence
		return (size());
		}

	virtual bool empty_virtual() sealed
		= _Mycont_it::empty
		{	// test if sequence is empty
		return (empty());
		}

	// mutators
//	void push_front(value_type _Val);
//	void pop_front();

	virtual void push_back_virtual(value_type _Val) sealed
		= _Mycont_it::push_back
		{	// insert element at end
		push_back(_Val);
		}

	virtual void pop_back_virtual() sealed
		= _Mycont_it::pop_back
		{	// erase element at end
		pop_back();
		}

	virtual void assign_virtual(size_type _Count, value_type _Val) sealed
		= _Mycont_it::assign
		{	// assign _Count * _Val
		assign(_Count, _Val);
		}

	virtual void assign_virtual(
		_STLCLR Generic::IInputIterator<_Value_t>^ _First,
		_STLCLR Generic::IInputIterator<_Value_t>^ _Last) sealed
		= _Mycont_it::assign
		{	// initialize with [_First, _Last), input iterators
		assign(_First, _Last);
		}

	virtual void assign_virtual(
		System::Collections::IEnumerable^ _Right) sealed
		= _Mycont_it::assign
		{	// initialize with enumeration
		assign(_Right);
		}

	virtual generic_iterator insert_virtual(generic_iterator _Where,
		value_type _Val) sealed
		= _Mycont_it::insert
		{	// insert _Val at _Where
		return (insert(iterator(_Where), _Val));
		}

	virtual void insert_virtual(generic_iterator _Where,
		size_type _Count, value_type _Val) sealed
			= _Mycont_it::insert
		{	// insert _Count * _Val at _Where
		return (insert(iterator(_Where), _Count, _Val));
		}

	virtual void insert_virtual(generic_iterator _Where_iter,
		_STLCLR Generic::IInputIterator<_Value_t>^ _First,
		_STLCLR Generic::IInputIterator<_Value_t>^ _Last) sealed
			= _Mycont_it::insert
		{	// insert [_First, _Last) at _Where, input iterators
		insert(iterator(_Where_iter), _First, _Last);
		}

	virtual void insert_virtual(generic_iterator _Where_iter,
		System::Collections::IEnumerable^ _Right) sealed
			= _Mycont_it::insert
		{	// insert enumeration at _Where, possibly from this container
		insert(iterator(_Where_iter), _Right);
		}

	virtual generic_iterator erase_virtual(generic_iterator _Where) sealed
		= _Mycont_it::erase
		{	// erase element at _Where
		return (erase(iterator(_Where)));
		}

	virtual generic_iterator erase_virtual(generic_iterator _First,
		generic_iterator _Last) sealed
		= _Mycont_it::erase
		{	// erase [_First, _Last)
		return (erase(iterator(_First), iterator(_Last)));
		}

	virtual void clear_virtual() sealed
		= _Mycont_it::clear
		{	// erase all
		clear();
		}

	virtual void swap_virtual(_Mycont_it^ _Right) sealed
		= _Mycont_it::swap
		{	// exchange contents with _Right
		swap(*(_Mytype_t^)_Right);
		}
	};

//
// TEMPLATE REF CLASS vector_base
//
template<typename _Value_t,
	bool _Is_ref>
	ref class vector_base
	:	public vector_impl<_Value_t, _Is_ref>,
			System::Collections::Generic::ICollection<_Value_t>,
			System::Collections::Generic::IEnumerable<_Value_t>,
			System::Collections::Generic::IList<_Value_t>
	{	// varying size array of elements
public:
	// types
	typedef vector_base<_Value_t, _Is_ref> _Mytype_t;
	typedef vector_impl<_Value_t, _Is_ref> _Mybase_t;
//	typedef _STLCLR IVector<_Value_t> _Mycont_it;
	typedef _Cont_make_value<_Value_t, _Is_ref> _Mymake_t;

//	typedef int size_type;
//	typedef int difference_type;
//	typedef _Value_t value_type;
//	typedef value_type% reference;
//	typedef value_type% const_reference;

//	typedef _Mycont_it generic_container;
//	typedef value_type generic_value;

	// basics
	vector_base()
		:	_Mybase_t()
		{	// construct default
		}

	vector_base(vector_base% _Right)
		:	_Mybase_t(_Right)
		{	// construct by copying a vector
		}

	vector_base% operator=(vector_base% _Right)
		{	// assign
		_Mybase_t::operator=(_Right);
		return (*this);
		}

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

	// constructors
	explicit vector_base(size_type _Count)
		:	_Mybase_t(_Count)
		{	// construct from _Count * value_type()
		}

	vector_base(size_type _Count, value_type _Val)
		:	_Mybase_t(_Count, _Val)
		{	// construct from _Count * _Val
		}

	template<typename _InIt_t>
		vector_base(_InIt_t _First, _InIt_t _Last)
		:	_Mybase_t(_First, _Last)
		{	// construct from [_First, _Last)
		}

	vector_base(_Myenum_it^ _Right)
		:	_Mybase_t(_Right)
		{	// initialize with enumeration
		}

	// mutators
	template<typename _InIt_t>
		void assign(_InIt_t _First, _InIt_t _Last)
		{	// assign [_First, _Last)
		_Assign(_First, _Last, _Iter_category(_First));
		}

	template<typename _InIt_t>
		void _Assign(_InIt_t _Count, _InIt_t _Val,
			_Int_iterator_tag%)
		{	// assign _Count * _Val
		clear();
		insert_n(0, (size_type)_Count, (value_type)_Val);
		}

	template<typename _InIt_t>
		void _Assign(_InIt_t _First, _InIt_t _Last,
			input_iterator_tag%)
		{	// initialize with [_First, _Last), input iterators
		if (_Iter_container(_First) != this)
			clear();

		size_type _Oldsize = size();

		for (; _First != _Last; ++_First)
			insert_n(size(), 1, (value_type)*_First);	// append new stuff
		erase_n(0, _Oldsize);	// erase any leftover old stuff
		}

	template<typename _InIt_t>
		void _Assign(_InIt_t _First, _InIt_t _Last,
			random_access_iterator_tag%)
		{	// initialize with [_First, _Last), input iterators
		if (_Last < _First)
			throw gcnew System::ArgumentOutOfRangeException();

		if (_Iter_container(_First) != this)
			clear();

		size_type _Oldsize = size();

		for (; _First != _Last; ++_First)
			insert_n(size(), 1, (value_type)*_First);	// append new stuff
		erase_n(0, _Oldsize);	// erase any leftover old stuff
		}

	template<typename _InIt_t>
		void insert(iterator _Where, _InIt_t _First, _InIt_t _Last)
		{	// insert [_First, _Last) at _Where
		_Insert(get_bias(_Where), _First, _Last,
			_Iter_category(_First));
		}

	template<typename _InIt_t>
		void _Insert(size_type _Where, _InIt_t _First, _InIt_t _Last,
			_Int_iterator_tag%)
		{	// insert _Count * _Val at _Where
		insert_n(_Where, (size_type)_First, (value_type)_Last);
		}

	template<typename _InIt_t>
		void _Insert(size_type _Where, _InIt_t _First, _InIt_t _Last,
			input_iterator_tag%)
		{	// insert [_First, _Last) at _Where, input iterators
		if (_Iter_container(_First) == this)
			_Insert_self(_Where, _First, _Last);
		else
			for (; _First != _Last; ++_First, ++_Where)
				_Where = insert_n(_Where, 1, (value_type)*_First);
		}

	template<typename _InIt_t>
		void _Insert(size_type _Where, _InIt_t _First, _InIt_t _Last,
			forward_iterator_tag%)
		{	// insert [_First, _Last) at _Where, forward iterators
		if (_Iter_container(_First) == this)
			_Insert_self(_Where, _First, _Last);
		else
			{	// not inserting from this container, dig a hole and fill it
			size_type _Size = cliext::distance(_First, _Last);

			if (_Size < 0)
				throw gcnew System::ArgumentOutOfRangeException();
			_Insert_space(_Where, _Size);
			for (size_type _Idx = 0; _Idx < _Size; ++_Idx, ++_First)
				_Myarray[_Where + _Idx] =
					_Mymake_t::make_value(value_type(*_First));