vector

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

// vector stl/clr header
#ifndef _CLI_VECTOR_
 #define _CLI_VECTOR_
#include <cliext/iterator>

namespace cliext {
	namespace impl {
//
// TEMPLATE CLASS vector_impl
//
template<typename _Value_t,
	bool _Is_ref>
	ref class vector_impl
	:	public _STLCLR IVector<_Value_t>
	{	// varying size array of elements
public:
	// types
	typedef vector_impl<_Value_t, _Is_ref> _Mytype_t;
	typedef _STLCLR IVector<_Value_t> _Mycont_it;
	typedef cli::array<_Value_t> _Myarray_t;
	typedef System::Collections::Generic::IEnumerable<_Value_t> _Myenum_it;
	typedef _Cont_make_value<_Value_t, _Is_ref> _Mymake_t;

	typedef RandomAccessIterator<_Mytype_t>
		iterator;
	typedef ConstRandomAccessIterator<_Mytype_t>
		const_iterator;
	typedef ReverseRandomAccessIterator<_Mytype_t>
		reverse_iterator;
	typedef ReverseRandomAccessIterator<_Mytype_t>
		const_reverse_iterator;

	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;
	typedef _STLCLR Generic::ContainerRandomAccessIterator<_Value_t>
		generic_iterator;
	typedef _STLCLR Generic::ReverseRandomAccessIterator<_Value_t>
		generic_reverse_iterator;

	// constants
	static const int _Maxsize = MAX_CONTAINER_SIZE;

	// basics
	vector_impl()
		{	// construct empty vector
		_Buy(0);
		}

	vector_impl% operator=(vector_impl% _Right)
		{	// assign
		if ((Object^)this != %_Right)
			{	// worth doing, do it
			clear();
			reserve(_Right.size());

			for (size_type _Idx = 0; _Idx < _Right.size(); ++_Idx)
				insert_n(size(), 1, _Right.at(_Idx));
			}
		return (*this);
		}

	// constructors
	vector_impl(_Mytype_t% _Right)
		{	// construct by copying _Right
		for (size_type _Idx = _Buy(_Right.size()); 0 <= --_Idx; )
			_Myarray[_Idx] = _Mymake_t::make_value(_Right.at(_Idx));
		_Mysize = _Right.size();
		}

	explicit vector_impl(size_type _Count)
		{	// construct from _Count * value_type()
		_Mysize = _Fill_n(0, _Buy(_Count), value_type());
		}

	vector_impl(size_type _Count, value_type _Val)
		{	// construct from _Count * _Val
		_Mysize = _Fill_n(0, _Buy(_Count), _Val);
		}

	template<typename _InIt_t>
		vector_impl(_InIt_t _First, _InIt_t _Last)
		{	// construct from [_First, _Last)
		_Construct(_First, _Last, _Iter_category(_First));
		}

	template<typename _InIt_t>
		void _Construct(_InIt_t _Count, _InIt_t _Val,
			_Int_iterator_tag%)
		{	// initialize with _Count * _Val
		_Mysize = _Fill_n(0, _Buy((size_type)_Count), (value_type)_Val);
		}

	template<typename _InIt_t>
		void _Construct(_InIt_t _First, _InIt_t _Last,
			input_iterator_tag%)
		{	// initialize with [_First, _Last), input iterators
		_Buy(_First != _Last ? 1 : 0);	// buy at least one if non-empty
		for (; _First != _Last; ++_First)
			insert_n(size(), 1, (value_type)*_First);
		}

	template<typename _InIt_t>
		void _Construct(_InIt_t _First, _InIt_t _Last,
			forward_iterator_tag%)
		{	// initialize with [_First, _Last), forward iterators
		size_type _Size = cliext::distance(_First, _Last);

		_Buy(_Size);
		for (size_type _Idx = 0; _Idx < _Size; ++_Idx, ++_First)
			_Myarray[_Idx] = _Mymake_t::make_value(value_type(*_First));
		_Mysize = _Size;
		}

	vector_impl(_Myenum_it^ _Right)
		{	// initialize with enumeration
		_Buy(0);
		for each (value_type _Val in _Right)
			push_back(_Val);
		}

	// destructor
	~vector_impl()
		{	// destroy the object
		clear();
		_Myarray = nullptr;
		_Mysize = 0;
		++_Mygen;
		}

	// accessors
	unsigned long get_generation()
		{	// get underlying container generation
		return (_Mygen);
		}

	size_type get_bias(iterator _Where)
		{	// get offset from valid iterator
		if (_Where.container() != this)
			throw gcnew System::ArgumentException();
		return (_Where.get_bias());
		}

	bool valid_bias(size_type _Bias)
		{	// test if _Bias is currently a valid bias
		return (0 <= _Bias && _Bias <= size());
		}

	reference at(size_type _Pos)
		{	// subscript mutable sequence with checking
		if (_Pos < 0 || size() <= _Pos)
			throw gcnew System::ArgumentOutOfRangeException();

		return (_Myarray[_Pos]);
		}

	reference at_bias(size_type _Bias)
		{	// subscript mutable sequence with checking, biased
		return (at(_Bias));
		}

	property value_type default[size_type]
		{	// get or set subscripted element
		virtual value_type get(size_type _Pos)
			{	// get _Pos element
			return (at(_Pos));
			}

		virtual void set(size_type _Pos, value_type _Val)
			{	// set _Pos element
			at(_Pos) = _Val;
			}
		};

	property value_type front_item
		{	// get or set first element
		virtual value_type get()
			{	// get first element
			return (front());
			}

		virtual void set(value_type _Val)
			{	// set first element
			front() = _Val;
			}
		};

	property value_type back_item
		{	// get or set last element
		virtual value_type get()
			{	// get last element
			return (back());
			}

		virtual void set(value_type _Val)
			{	// set last element
			back() = _Val;
			}
		};

	reference front()
		{	// get first element of mutable sequence
		if (empty())
			throw gcnew System::NullReferenceException();
		return (at(0));
		}

	reference back()
		{	// get last element of mutable sequence
		if (empty())
			throw gcnew System::NullReferenceException();
		return (at(size() - 1));
		}

	// converters
	_Myarray_t^ to_array()
		{	// convert to array
		_Myarray_t^ _Ans = gcnew _Myarray_t(size());

		for (int _Idx = size(); 0 <= --_Idx; )
			_Ans[_Idx] = _Mymake_t::make_value(_Myarray[_Idx]);
		return (_Ans);
		}

	// iterator generators
	iterator make_iterator(size_type _Bias)
		{	// return iterator for offset
		return (iterator(this, _Bias));
		}

	iterator begin()
		{	// return iterator for beginning of mutable sequence
		return (make_iterator(0));
		}
	iterator end()
		{	// return iterator for end of mutable sequence
		return (make_iterator(size()));
		}

	reverse_iterator rbegin()
		{	// return reverse iterator for beginning of mutable sequence
		return (reverse_iterator(end()));
		}

	reverse_iterator rend()
		{	// return reverse iterator for end of mutable sequence
		return (reverse_iterator(begin()));
		}

	// size controllers
	void reserve(size_type _Capacity)
		{	// determine new minimum length of allocated storage
		if (_Capacity < 0)
			throw gcnew System::ArgumentOutOfRangeException();

		if (capacity() < _Capacity)
			{	// not enough room, reallocate
			_Myarray_t^ _Oldarray = _Myarray;

			_Myarray = gcnew _Myarray_t(_Capacity);
			for (size_type _Idx = size(); 0 <= --_Idx; )
				_Myarray[_Idx] = _Oldarray[_Idx];
			}
		}

	size_type capacity()
		{	// return current length of allocated storage
		return (_Myarray == nullptr ? 0 : _Myarray->Length);
		}

	virtual void resize(size_type _Newsize)
		{	// determine new length, padding with value_type elements
		resize(_Newsize, value_type());
		}

	void resize(size_type _Newsize, value_type _Val)
		{	// determine new length, padding with _Val elements
		if (_Newsize < 0)
			throw gcnew System::ArgumentOutOfRangeException();

		if (size() < _Newsize)
			insert_n(size(), _Newsize - size(), _Val);
		else if (_Newsize < size())
			erase_n(_Newsize, size());
		}

	size_type size()
		{	// return length of sequence
		return (_Mysize);
		}

	bool empty()
		{	// test if sequence is empty
		return (size() == 0);
		}

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

	void push_back(value_type _Val)
		{	// insert element at end
		insert_n(size(), 1, _Val);
		}

	void pop_back()
		{	// erase element at end
		erase_n(size() - 1, size());	// discard from end
		}

	void assign(size_type _Count, value_type _Val)
		{	// assign _Count * _Val
		clear();
		insert_n(0, _Count, _Val);
		}

	void assign(_STLCLR Generic::IInputIterator<_Value_t>^ _First,
		_STLCLR Generic::IInputIterator<_Value_t>^ _Last)
		{	// initialize with [_First, _Last), input iterators
		if (_Iter_container(_First) != this)
			clear();

		size_type _Oldsize = size();

		for (; !_First->equal_to(_Last); _First->next())
			insert_n(size(),
				1, (value_type)_First->get_cref());	// append new stuff
		erase_n(0, _Oldsize);	// erase any leftover old stuff
		}

	void assign(_Myenum_it^ _Right)
		{	// initialize with enumeration
		size_type _Oldsize = size();

		for each (value_type _Val in _Right)
			insert_n(size(), 1, _Val);	// append new stuff
		erase_n(0, _Oldsize);	// erase any leftover old stuff
		}

	void assign(System::Collections::IEnumerable^ _Right)
		{	// initialize with enumeration
		size_type _Oldsize = size();

		for each (value_type _Val in _Right)
			insert_n(size(), 1, _Val);	// append new stuff
		erase_n(0, _Oldsize);	// erase any leftover old stuff
		}

	iterator insert(iterator _Where, value_type _Val)
		{	// insert _Val at _Where
		return (make_iterator(
			insert_n(get_bias(_Where), 1, _Val)));
		}

	void insert(iterator _Where,
		size_type _Count, value_type _Val)
		{	// insert _Count * _Val at _Where
		insert_n(get_bias(_Where), _Count, _Val);
		}

	void insert(iterator _Where_iter,
		_STLCLR Generic::IInputIterator<_Value_t>^ _First,
		_STLCLR Generic::IInputIterator<_Value_t>^ _Last)
		{	// insert [_First, _Last) at _Where, input iterators
		size_type _Where = get_bias(_Where_iter);
		size_type _Oldsize = size();

		if (!valid_bias(_Where))
			throw gcnew System::InvalidOperationException();

		for (; !_First->equal_to(_Last); _First->next())
			insert_n(size(), 1, (value_type)_First->get_cref());
		reverse_n(_Where, _Oldsize);
		reverse_n(_Oldsize, size());
		reverse_n(_Where, size());
		}

	void insert(iterator _Where_iter,
		_Myenum_it^ _Right)
		{	// insert enumeration at _Where, possibly from this container
		size_type _Where = get_bias(_Where_iter);
		size_type _Oldsize = size();

		if (!valid_bias(_Where))
			throw gcnew System::InvalidOperationException();

		for each (value_type _Val in _Right)
			insert_n(size(), 1, _Val);
		reverse_n(_Where, _Oldsize);
		reverse_n(_Oldsize, size());
		reverse_n(_Where, size());
		}

	void insert(iterator _Where_iter,
		System::Collections::IEnumerable^ _Right)
		{	// insert enumeration at _Where, possibly from this container
		size_type _Where = get_bias(_Where_iter);
		size_type _Oldsize = size();

		if (!valid_bias(_Where))
			throw gcnew System::InvalidOperationException();

		for each (value_type _Val in _Right)
			insert_n(size(), 1, _Val);
		reverse_n(_Where, _Oldsize);
		reverse_n(_Oldsize, size());
		reverse_n(_Where, size());
		}

	template<typename _InIt_t>
		void _Insert_self(size_type _Where, _InIt_t _First, _InIt_t _Last)
		{	// insert [_First, _Last] at _Where, from this container
		size_type _Oldsize = size();

		if (!valid_bias(_Where))
			throw gcnew System::InvalidOperationException();

		for (; _First != _Last; ++_First)
			insert_n(size(), 1, (value_type)*_First);
		reverse_n(_Where, _Oldsize);
		reverse_n(_Oldsize, size());
		reverse_n(_Where, size());
		}

	size_type insert_n(size_type _Where,
		size_type _Count, value_type _Val)
		{	// insert _Count * _Val at _Where
		if (_Count < 0)
			throw gcnew System::ArgumentOutOfRangeException();

		if (_Count == 0)
			return (_Where);
		else
			{	// insert finite sequence
			_Insert_space(_Where, _Count);
			_Fill_n(_Where, _Count, _Val);
			++_Mygen;
			return (_Where + _Count - 1);
			}
		}

	iterator erase(iterator _Where)
		{	// erase element at _Where
		size_type _Bias = get_bias(_Where);

		return (make_iterator(erase_n(_Bias, _Bias + 1)));
		}

	iterator erase(iterator _First, iterator _Last)
		{	// erase [_First, _Last)
		return (make_iterator(
			erase_n(get_bias(_First), get_bias(_Last))));
		}

	size_type erase_n(size_type _First, size_type _Last)
		{	// erase [_First, _Last)
		if (_First < 0 || _Last < _First || size() < _Last)
			throw gcnew System::InvalidOperationException();

		if (_First != _Last)
			{	// worth doing, copy down over hole
			for (size_type _Next = _First; _Next != _Last; ++_Next)
				_Mymake_t::unmake_value(at(_Next));

			_Mysize = _Copy(_Myarray, _Last, size(), _First);
			++_Mygen;
			}
		return (_First);
		}

	void reverse_n(size_type _First, size_type _Last)
		{	// reverse a subrange
		bool _Changed = false;

		for (; _First != _Last && _First != --_Last; ++_First)
			{	// swap distinct _First and _Last
			value_type _Temp = _Myarray[_First];

			_Myarray[_First] = _Myarray[_Last];
			_Myarray[_Last] = _Temp;
			_Changed = true;
			}
		if (_Changed)
			++_Mygen;
		}

	void clear()