STLdoc: vector< _Ty, _Alloc > Class Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Inheritance diagram for vector< _Ty, _Alloc >:

Public Types
typedef vector< _Ty, _Alloc >	_Myt

typedef _Vector_alloc< _Vec_base_types< _Ty, _Alloc > >	_Mybase

typedef _Alloc	allocator_type

typedef _Mybase::_Alty	_Alty

typedef _Mybase::value_type	value_type

typedef _Mybase::size_type	size_type

typedef _Mybase::difference_type	difference_type

typedef _Mybase::pointer	pointer

typedef _Mybase::const_pointer	const_pointer

typedef _Mybase::reference	reference

typedef _Mybase::const_reference	const_reference

typedef _Mybase::iterator	iterator

typedef _Mybase::const_iterator	const_iterator

typedef _STD reverse_iterator< iterator >	reverse_iterator

typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator

Public Types inherited from _Vector_alloc< _Vec_base_types< _Ty, _Alloc > >
typedef _Vector_alloc< _Vec_base_types< _Ty, _Alloc > >	_Myt

typedef _Vec_base_types< _Ty, _Alloc >::_Alloc	_Alloc

typedef _Vec_base_types< _Ty, _Alloc >::_Alty	_Alty

typedef _Vec_base_types< _Ty, _Alloc >::_Val_types	_Val_types

typedef _Val_types::value_type	value_type

typedef _Val_types::size_type	size_type

typedef _Val_types::difference_type	difference_type

typedef _Val_types::pointer	pointer

typedef _Val_types::const_pointer	const_pointer

typedef _Val_types::reference	reference

typedef _Val_types::const_reference	const_reference

typedef _Vector_iterator< _Vector_val< _Val_types > >	iterator

typedef _Vector_const_iterator< _Vector_val< _Val_types > >	const_iterator

Public Member Functions
	vector () _NOEXCEPT_OP(is_nothrow_default_constructible< _Alloc >

	vector (const _Alloc &_Al) _NOEXCEPT

	vector (size_type _Count)

	vector (size_type _Count, const value_type &_Val)

	vector (size_type _Count, const value_type &_Val, const _Alloc &_Al)

	vector (const _Myt &_Right)

	vector (const _Myt &_Right, const _Alloc &_Al)

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	vector (_Iter _First, _Iter _Last)

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	vector (_Iter _First, _Iter _Last, const _Alloc &_Al)

template<class _Iter >
void	_Construct (_Iter _First, _Iter _Last)

template<class _Iter >
void	_Construct (_Iter _First, _Iter _Last, input_iterator_tag)

template<class _Iter >
void	_Construct (_Iter _First, _Iter _Last, forward_iterator_tag)

void	_Construct_n (size_type _Count, const value_type *_Pval)

	vector (_Myt &&_Right) _NOEXCEPT

	vector (_Myt &&_Right, const _Alloc &_Al)

_Myt &	operator= (_Myt &&_Right) _NOEXCEPT_OP(_Alty

void	_Assign_rv (_Myt &&_Right, true_type)

void	_Assign_rv (_Myt &&_Right, false_type)

void	_Assign_rv (_Myt &&_Right)

void	push_back (value_type &&_Val)

iterator	insert (const_iterator _Where, _Ty &&_Val)

template<class... _Valty>
void	emplace_back (_Valty &&..._Val)

template<class... _Valty>
iterator	emplace (const_iterator _Where, _Valty &&..._Val)

	vector (_XSTD initializer_list< value_type > _Ilist, const _Alloc &_Al=allocator_type())

_Myt &	operator= (_XSTD initializer_list< value_type > _Ilist)

void	assign (_XSTD initializer_list< value_type > _Ilist)

iterator	insert (const_iterator _Where, _XSTD initializer_list< value_type > _Ilist)

	~vector () _NOEXCEPT

_Myt &	operator= (const _Myt &_Right)

void	reserve (size_type _Count)

size_type	capacity () const _NOEXCEPT

size_type	_Unused_capacity () const _NOEXCEPT

size_type	_Has_unused_capacity () const _NOEXCEPT

iterator	begin () _NOEXCEPT

const_iterator	begin () const _NOEXCEPT

iterator	end () _NOEXCEPT

const_iterator	end () const _NOEXCEPT

iterator	_Make_iter (const_iterator _Where) const

reverse_iterator	rbegin () _NOEXCEPT

const_reverse_iterator	rbegin () const _NOEXCEPT

reverse_iterator	rend () _NOEXCEPT

const_reverse_iterator	rend () const _NOEXCEPT

const_iterator	cbegin () const _NOEXCEPT

const_iterator	cend () const _NOEXCEPT

const_reverse_iterator	crbegin () const _NOEXCEPT

const_reverse_iterator	crend () const _NOEXCEPT

void	shrink_to_fit ()

void	resize (size_type _Newsize)

void	resize (size_type _Newsize, const value_type &_Val)

size_type	size () const _NOEXCEPT

size_type	max_size () const _NOEXCEPT

bool	empty () const _NOEXCEPT

_Alloc	get_allocator () const _NOEXCEPT

const_reference	at (size_type _Pos) const

reference	at (size_type _Pos)

const_reference	operator[] (size_type _Pos) const

reference	operator[] (size_type _Pos)

_Ty *	data () _NOEXCEPT

const _Ty *	data () const _NOEXCEPT

reference	front ()

const_reference	front () const

reference	back ()

const_reference	back () const

void	push_back (const value_type &_Val)

void	pop_back ()

template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, void >::type	assign (_Iter _First, _Iter _Last)

template<class _Iter >
void	_Assign (_Iter _First, _Iter _Last, input_iterator_tag)

template<class _Iter >
void	_Assign (_Iter _First, _Iter _Last, forward_iterator_tag)

void	assign (size_type _Count, const value_type &_Val)

iterator	insert (const_iterator _Where, const _Ty &_Val)

iterator	insert (const_iterator _Where, size_type _Count, const _Ty &_Val)

template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, iterator >::type	insert (const_iterator _Where, _Iter _First, _Iter _Last)

template<class _Iter >
void	_Insert (const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag)

template<class _Iter >
void	_Insert (const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag)

iterator	erase (const_iterator _Where)

iterator	erase (const_iterator _First_arg, const_iterator _Last_arg)

void	_Pop_back_n (size_type _Count)

void	clear () _NOEXCEPT

void	swap (_Myt &_Right) _NOEXCEPT_OP(_Alty

Public Member Functions inherited from _Vector_alloc< _Vec_base_types< _Ty, _Alloc > >
	_Vector_alloc ()

	_Vector_alloc (_Any_alloc &&_Al)

void	_Copy_alloc (const _Alty &_Al)

void	_Move_alloc (_Alty &_Al)

void	_Orphan_all ()

void	_Swap_all (_Myt &_Right)

_Alty &	_Getal () _NOEXCEPT

const _Alty &	_Getal () const _NOEXCEPT

_Vector_val< _Val_types > &	_Get_data () _NOEXCEPT

const _Vector_val< _Val_types > &	_Get_data () const _NOEXCEPT

pointer &	_Myfirst () _NOEXCEPT

const pointer &	_Myfirst () const _NOEXCEPT

pointer &	_Mylast () _NOEXCEPT

const pointer &	_Mylast () const _NOEXCEPT

pointer &	_Myend () _NOEXCEPT

const pointer &	_Myend () const _NOEXCEPT

Protected Member Functions
bool	_Buy (size_type _Capacity)

void	_Destroy (pointer _First, pointer _Last)

size_type	_Grow_to (size_type _Count) const

bool	_Inside (const value_type *_Ptr) const

void	_Reallocate (size_type _Count)

void	_Reserve (size_type _Count)

void	_Tidy ()

template<class _Iter >
pointer	_Ucopy (_Iter _First, _Iter _Last, pointer _Ptr)

template<class _Iter >
pointer	_Umove (_Iter _First, _Iter _Last, pointer _Ptr)

iterator	_Insert_n (const_iterator _Where, size_type _Count, const value_type &_Val)

pointer	_Ufill (pointer _Ptr, size_type _Count, const value_type *_Pval)

void	_Xlen () const

void	_Xran () const

void	_Orphan_range (pointer, pointer) const

Member Typedef Documentation

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::_Alty vector< _Ty, _Alloc >::_Alty

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Vector_alloc<_Vec_base_types<_Ty, _Alloc> > vector< _Ty, _Alloc >::_Mybase

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef vector<_Ty, _Alloc> vector< _Ty, _Alloc >::_Myt

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Alloc vector< _Ty, _Alloc >::allocator_type

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::const_iterator vector< _Ty, _Alloc >::const_iterator

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::const_pointer vector< _Ty, _Alloc >::const_pointer

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::const_reference vector< _Ty, _Alloc >::const_reference

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _STD reverse_iterator<const_iterator> vector< _Ty, _Alloc >::const_reverse_iterator

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::difference_type vector< _Ty, _Alloc >::difference_type

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::iterator vector< _Ty, _Alloc >::iterator

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::pointer vector< _Ty, _Alloc >::pointer

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::reference vector< _Ty, _Alloc >::reference

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _STD reverse_iterator<iterator> vector< _Ty, _Alloc >::reverse_iterator

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::size_type vector< _Ty, _Alloc >::size_type

template<class _Ty, class _Alloc = allocator<_Ty>>

typedef _Mybase::value_type vector< _Ty, _Alloc >::value_type

Constructor & Destructor Documentation

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector ( )

inline

         : _Mybase()
         {   // construct empty vector
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector ( const _Alloc & _Al )

inlineexplicit

         : _Mybase(_Al)
         {   // construct empty vector, allocator
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector ( size_type _Count )

inlineexplicit

         : _Mybase()
         {   // construct from _Count * value_type()
         if (_Buy(_Count))
             {   // nonzero, fill it
             _TRY_BEGIN
             _Uninitialized_default_fill_n(this->_Myfirst(), _Count,
                 this->_Getal());
             this->_Mylast() += _Count;
             _CATCH_ALL
             _Tidy();
             _RERAISE;
             _CATCH_END
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector	(	size_type	_Count,
		const value_type &	_Val
	)

inline

         : _Mybase()
         {   // construct from _Count * _Val
         _Construct_n(_Count, _STD addressof(_Val));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector	(	size_type	_Count,
		const value_type &	_Val,
		const _Alloc &	_Al
	)

inline

         : _Mybase(_Al)
         {   // construct from _Count * _Val, allocator
         _Construct_n(_Count, _STD addressof(_Val));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector ( const _Myt & _Right )

inline

         : _Mybase(_Right._Getal().select_on_container_copy_construction())
 
 
         {   // construct by copying _Right
         if (_Buy(_Right.size()))
             _TRY_BEGIN
             this->_Mylast() = _Ucopy(_Right.begin(), _Right.end(),
                 this->_Myfirst());
             _CATCH_ALL
             _Tidy();
             _RERAISE;
             _CATCH_END
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector	(	const _Myt &	_Right,
		const _Alloc &	_Al
	)

inline

         : _Mybase(_Al)
         {   // construct by copying _Right, allocator
         if (_Buy(_Right.size()))
             _TRY_BEGIN
             this->_Mylast() = _Ucopy(_Right.begin(), _Right.end(),
                 this->_Myfirst());
             _CATCH_ALL
             _Tidy();
             _RERAISE;
             _CATCH_END
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>

vector< _Ty, _Alloc >::vector	(	_Iter	_First,
		_Iter	_Last
	)

inline

         : _Mybase()
         {   // construct from [_First, _Last)
         _Construct(_First, _Last);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>

vector< _Ty, _Alloc >::vector	(	_Iter	_First,
		_Iter	_Last,
		const _Alloc &	_Al
	)

inline

         : _Mybase(_Al)
         {   // construct from [_First, _Last) with allocator
         _Construct(_First, _Last);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector ( _Myt && _Right )

inline

         : _Mybase(_STD move(_Right._Getal()))
         {   // construct by moving _Right
         _Assign_rv(_STD forward<_Myt>(_Right), true_type());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector	(	_Myt &&	_Right,
		const _Alloc &	_Al
	)

inline

         : _Mybase(_Al)
         {   // construct by moving _Right, allocator
         _Assign_rv(_STD forward<_Myt>(_Right));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::vector	(	_XSTD initializer_list< value_type >	_Ilist,
		const _Alloc &	_Al = `allocator_type()`
	)

inline

         : _Mybase(_Al)
         {   // construct from initializer_list
         _Construct(_Ilist.begin(), _Ilist.end());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

vector< _Ty, _Alloc >::~vector ( )

inline

         {   // destroy the object
         _Tidy();
         }

Member Function Documentation

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

void vector< _Ty, _Alloc >::_Assign	(	_Iter	_First,
		_Iter	_Last,
		input_iterator_tag
	)

inline

         {   // assign [_First, _Last), input iterators
         for (; _First != _Last; ++_First)
             emplace_back(*_First);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

void vector< _Ty, _Alloc >::_Assign	(	_Iter	_First,
		_Iter	_Last,
		forward_iterator_tag
	)

inline

         {   // assign [_First, _Last), forward iterators
         size_type _Newsize = _STD distance(_First, _Last);
 
         if (capacity() < _Newsize)
             {   // need more room, try to get it
             size_type _Newcapacity = _Grow_to(_Newsize);
             _Tidy();
             _Buy(_Newcapacity);
             }
 
         this->_Mylast() = _Ucopy(_First, _Last, this->_Myfirst());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Assign_rv	(	_Myt &&	_Right,
		true_type
	)

inline

         {   // move from _Right, stealing its contents
         this->_Swap_all((_Myt&)_Right);
         this->_Myfirst() = _Right._Myfirst();
         this->_Mylast() = _Right._Mylast();
         this->_Myend() = _Right._Myend();
 
         _Right._Myfirst() = pointer();
         _Right._Mylast() = pointer();
         _Right._Myend() = pointer();
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Assign_rv	(	_Myt &&	_Right,
		false_type
	)

inline

         {   // move from _Right, possibly moving its contents
         if (get_allocator() == _Right.get_allocator())
             _Assign_rv(_STD forward<_Myt>(_Right), true_type());
         else
             _Construct(_STD make_move_iterator(_Right.begin()),
                 _STD make_move_iterator(_Right.end()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Assign_rv ( _Myt && _Right )

inline

         {   // assign by moving _Right
         _Assign_rv(_STD forward<_Myt>(_Right),
             typename _Alty::propagate_on_container_move_assignment());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

bool vector< _Ty, _Alloc >::_Buy ( size_type _Capacity )

inlineprotected

         {   // allocate array with _Capacity elements
         this->_Myfirst() = pointer();
         this->_Mylast() = pointer();
         this->_Myend() = pointer();
 
         if (_Capacity == 0)
             return (false);
         else if (max_size() < _Capacity)
             _Xlen();    // result too long
         else
             {   // nonempty array, allocate storage
             this->_Myfirst() = this->_Getal().allocate(_Capacity);
             this->_Mylast() = this->_Myfirst();
             this->_Myend() = this->_Myfirst() + _Capacity;
             }
         return (true);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

void vector< _Ty, _Alloc >::_Construct	(	_Iter	_First,
		_Iter	_Last
	)

inline

         {   // initialize with [_First, _Last)
         _Construct(_First, _Last, _Iter_cat_t<_Iter>());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

void vector< _Ty, _Alloc >::_Construct	(	_Iter	_First,
		_Iter	_Last,
		input_iterator_tag
	)

inline

         {   // initialize with [_First, _Last), input iterators
         _TRY_BEGIN
 
         for (; _First != _Last; ++_First)
             emplace_back(*_First);
 
         _CATCH_ALL
         _Tidy();
         _RERAISE;
         _CATCH_END
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

void vector< _Ty, _Alloc >::_Construct	(	_Iter	_First,
		_Iter	_Last,
		forward_iterator_tag
	)

inline

         {   // initialize with [_First, _Last), forward iterators
         if (_Buy(_STD distance(_First, _Last)))
             {   // nonzero, fill it
             _TRY_BEGIN
             this->_Mylast() = _Ucopy(_First, _Last, this->_Myfirst());
             _CATCH_ALL
             _Tidy();
             _RERAISE;
             _CATCH_END
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Construct_n	(	size_type	_Count,
		const value_type *	_Pval
	)

inline

         {   // construct from _Count * *_Pval
         if (_Buy(_Count))
             {   // nonzero, fill it
             _TRY_BEGIN
             this->_Mylast() = _Ufill(this->_Myfirst(), _Count, _Pval);
             _CATCH_ALL
             _Tidy();
             _RERAISE;
             _CATCH_END
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Destroy	(	pointer	_First,
		pointer	_Last
	)

inlineprotected

         {   // destroy [_First, _Last) using allocator
         _Destroy_range(_First, _Last, this->_Getal());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

size_type vector< _Ty, _Alloc >::_Grow_to ( size_type _Count ) const

inlineprotected

         {   // grow by 50% or at least to _Count
         size_type _Capacity = capacity();
 
         _Capacity = max_size() - _Capacity / 2 < _Capacity
             ? 0 : _Capacity + _Capacity / 2;    // try to grow by 50%
         if (_Capacity < _Count)
             _Capacity = _Count;
         return (_Capacity);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

size_type vector< _Ty, _Alloc >::_Has_unused_capacity ( ) const

inline

         {   // micro-optimization for capacity() != size()
         return (this->_Myend() != this->_Mylast());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

void vector< _Ty, _Alloc >::_Insert	(	const_iterator	_Where,
		_Iter	_First,
		_Iter	_Last,
		input_iterator_tag
	)

inline

         {   // insert [_First, _Last) at _Where, input iterators
         size_type _Off = _VIPTR(_Where) - this->_Myfirst();
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (size() < _Off)
             _DEBUG_ERROR("vector insert iterator outside range");
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         if (_First != _Last)
             {   // worth doing, gather at end and rotate into place
             size_type _Oldsize = size();
 
             _TRY_BEGIN
             for (; _First != _Last; ++_First)
                 push_back(*_First); // append
 
             _CATCH_ALL
             erase(begin() + _Oldsize, end());
             _RERAISE;
             _CATCH_END
 
             _STD rotate(begin() + _Off, begin() + _Oldsize, end());
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

void vector< _Ty, _Alloc >::_Insert	(	const_iterator	_Where,
		_Iter	_First,
		_Iter	_Last,
		forward_iterator_tag
	)

inline

         {   // insert [_First, _Last) at _Where, forward iterators
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_VICONT(_Where) != &this->_Get_data()
             || _VIPTR(_Where) < this->_Myfirst()
             || this->_Mylast() < _VIPTR(_Where))
             _DEBUG_ERROR("vector insert iterator outside range");
         _DEBUG_RANGE(_First, _Last);
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         size_type _Count = _STD distance(_First, _Last);
         if (_Count == 0)
             ;
         else if (_Unused_capacity() < _Count)
             {   // not enough room, reallocate
             if (max_size() - size() < _Count)
                 _Xlen();    // result too long
 
             size_type _Capacity = _Grow_to(size() + _Count);
             pointer _Newvec = this->_Getal().allocate(_Capacity);
             pointer _Ptr = _Newvec;
 
             _TRY_BEGIN
             _Ptr = _Umove(this->_Myfirst(), _VIPTR(_Where),
                 _Newvec);   // copy prefix
             _Ptr = _Ucopy(_First, _Last, _Ptr); // add new stuff
             _Umove(_VIPTR(_Where), this->_Mylast(),
                 _Ptr);  // copy suffix
             _CATCH_ALL
             _Destroy(_Newvec, _Ptr);
             this->_Getal().deallocate(_Newvec, _Capacity);
             _RERAISE;
             _CATCH_END
 
             _Count += size();
             if (this->_Myfirst() != pointer())
                 {   // destroy and deallocate old array
                 _Destroy(this->_Myfirst(), this->_Mylast());
                 this->_Getal().deallocate(this->_Myfirst(),
                     this->_Myend() - this->_Myfirst());
                 }
 
             this->_Orphan_all();
             this->_Myend() = _Newvec + _Capacity;
             this->_Mylast() = _Newvec + _Count;
             this->_Myfirst() = _Newvec;
             }
         else
             {   // new stuff fits, append and rotate into place
             _Ucopy(_First, _Last, this->_Mylast());
             _STD rotate(_VIPTR(_Where), this->_Mylast(),
                 this->_Mylast() + _Count);
             this->_Mylast() += _Count;
             _Orphan_range(_VIPTR(_Where), this->_Mylast());
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::_Insert_n	(	const_iterator	_Where,
		size_type	_Count,
		const value_type &	_Val
	)

inlineprotected

         {   // insert _Count * _Val at _Where
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (_VICONT(_Where) != &this->_Get_data()
             || _VIPTR(_Where) < this->_Myfirst()
             || this->_Mylast() < _VIPTR(_Where))
             _DEBUG_ERROR("vector insert iterator outside range");
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         size_type _Off = _VIPTR(_Where) - this->_Myfirst();
         if (_Count == 0)
             ;
         else if (_Unused_capacity() < _Count)
             {   // not enough room, reallocate
             if (max_size() - size() < _Count)
                 _Xlen();    // result too long
 
             size_type _Capacity = _Grow_to(size() + _Count);
             pointer _Newvec = this->_Getal().allocate(_Capacity);
             size_type _Whereoff = _VIPTR(_Where) - this->_Myfirst();
             int _Ncopied = 0;
 
             _TRY_BEGIN
             _Ufill(_Newvec + _Whereoff, _Count,
                 _STD addressof(_Val));  // add new stuff
             ++_Ncopied;
             _Umove(this->_Myfirst(), _VIPTR(_Where),
                 _Newvec);   // copy prefix
             ++_Ncopied;
             _Umove(_VIPTR(_Where), this->_Mylast(),
                 _Newvec + (_Whereoff + _Count));    // copy suffix
             _CATCH_ALL
             if (1 < _Ncopied)
                 _Destroy(_Newvec, _Newvec + _Whereoff);
             if (0 < _Ncopied)
                 _Destroy(_Newvec + _Whereoff, _Newvec + _Whereoff + _Count);
             this->_Getal().deallocate(_Newvec, _Capacity);
             _RERAISE;
             _CATCH_END
 
             _Count += size();
             if (this->_Myfirst() != pointer())
                 {   // destroy and deallocate old array
                 _Destroy(this->_Myfirst(), this->_Mylast());
                 this->_Getal().deallocate(this->_Myfirst(),
                     this->_Myend() - this->_Myfirst());
                 }
 
             this->_Orphan_all();
             this->_Myend() = _Newvec + _Capacity;
             this->_Mylast() = _Newvec + _Count;
             this->_Myfirst() = _Newvec;
             }
         else if ((size_type)(this->_Mylast() - _VIPTR(_Where))
             < _Count)
             {   // new stuff spills off end
             value_type _Tmp = _Val; // in case _Val is in sequence
 
             _Umove(_VIPTR(_Where), this->_Mylast(),
                 _VIPTR(_Where) + _Count);   // copy suffix
 
             _TRY_BEGIN
             _Ufill(this->_Mylast(),
                 _Count - (this->_Mylast() - _VIPTR(_Where)),
                 _STD addressof(_Tmp));  // insert new stuff off end
             _CATCH_ALL
             _Destroy(_VIPTR(_Where) + _Count,
                 this->_Mylast() + _Count);
             _RERAISE;
             _CATCH_END
 
             this->_Mylast() += _Count;
             _Orphan_range(_VIPTR(_Where), this->_Mylast());
             _STD fill(_VIPTR(_Where), this->_Mylast() - _Count,
                 _Tmp);  // insert up to old end
             }
         else
             {   // new stuff can all be assigned
             value_type _Tmp = _Val; // in case _Val is in sequence
 
             pointer _Oldend = this->_Mylast();
             this->_Mylast() = _Umove(_Oldend - _Count, _Oldend,
                 this->_Mylast());   // copy suffix
 
             _Orphan_range(_VIPTR(_Where), this->_Mylast());
             _Move_backward_unchecked(_VIPTR(_Where), _Oldend - _Count,
                 _Oldend);   // copy hole
             _STD fill(_VIPTR(_Where),
                 _VIPTR(_Where) + _Count, _Tmp); // insert into hole
             }
         return (begin() + _Off);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

bool vector< _Ty, _Alloc >::_Inside ( const value_type * _Ptr ) const

inlineprotected

         {   // test if _Ptr points inside vector
         return (_Ptr < _Unfancy(this->_Mylast()) && _Unfancy(this->_Myfirst()) <= _Ptr);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::_Make_iter ( const_iterator _Where ) const

inline

         {   // make iterator from const_iterator
         return (iterator(_Where._Ptr, &this->_Get_data()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Orphan_range	(	pointer	,
		pointer
	)		const

inlineprotected

1793 { // orphan iterators within specified (inclusive) range

1794 }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Pop_back_n ( size_type _Count )

inline

         {   // erase _Count elements at end
         pointer _Ptr = this->_Mylast() - _Count;
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         _Orphan_range(_Ptr, this->_Mylast());
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         _Destroy(_Ptr, this->_Mylast());
         this->_Mylast() = _Ptr;
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Reallocate ( size_type _Count )

inlineprotected

         {   // move to array of exactly _Count elements
         pointer _Ptr = this->_Getal().allocate(_Count);
 
         _TRY_BEGIN
         _Umove(this->_Myfirst(), this->_Mylast(), _Ptr);
         _CATCH_ALL
         this->_Getal().deallocate(_Ptr, _Count);
         _RERAISE;
         _CATCH_END
 
         size_type _Size = size();
         if (this->_Myfirst() != pointer())
             {   // destroy and deallocate old array
             _Destroy(this->_Myfirst(), this->_Mylast());
             this->_Getal().deallocate(this->_Myfirst(),
                 this->_Myend() - this->_Myfirst());
             }
 
         this->_Orphan_all();
         this->_Myend() = _Ptr + _Count;
         this->_Mylast() = _Ptr + _Size;
         this->_Myfirst() = _Ptr;
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Reserve ( size_type _Count )

inlineprotected

         {   // ensure room for _Count new elements, grow exponentially
         if (_Unused_capacity() < _Count)
             {   // need more room, try to get it
             if (max_size() - size() < _Count)
                 _Xlen();
             _Reallocate(_Grow_to(size() + _Count));
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Tidy ( )

inlineprotected

         {   // free all storage
         if (this->_Myfirst() != pointer())
             {   // something to free, destroy and deallocate it
             this->_Orphan_all();
             _Destroy(this->_Myfirst(), this->_Mylast());
             this->_Getal().deallocate(this->_Myfirst(),
                 this->_Myend() - this->_Myfirst());
             this->_Myfirst() = pointer();
             this->_Mylast() = pointer();
             this->_Myend() = pointer();
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

pointer vector< _Ty, _Alloc >::_Ucopy	(	_Iter	_First,
		_Iter	_Last,
		pointer	_Ptr
	)

inlineprotected

         {   // copy initializing [_First, _Last), using allocator
         return (_Uninitialized_copy(_First, _Last,
             _Ptr, this->_Getal()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

pointer vector< _Ty, _Alloc >::_Ufill	(	pointer	_Ptr,
		size_type	_Count,
		const value_type *	_Pval
	)

inlineprotected

         {   // copy initializing _Count * _Val, using allocator
         _Uninitialized_fill_n(_Ptr, _Count, _Pval, this->_Getal());
         return (_Ptr + _Count);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

pointer vector< _Ty, _Alloc >::_Umove	(	_Iter	_First,
		_Iter	_Last,
		pointer	_Ptr
	)

inlineprotected

         {   // move initializing [_First, _Last), using allocator
         return (_Uninitialized_move(_First, _Last,
             _Ptr, this->_Getal()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

size_type vector< _Ty, _Alloc >::_Unused_capacity ( ) const

inline

         {   // micro-optimization for capacity() - size()
         return (this->_Myend() - this->_Mylast());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Xlen ( ) const

inlineprotected

         {   // report a length_error
         _Xlength_error("vector<T> too long");
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::_Xran ( ) const

inlineprotected

         {   // report an out_of_range error
         _Xout_of_range("invalid vector<T> subscript");
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::assign ( _XSTD initializer_list< value_type > _Ilist )

inline

         {   // assign initializer_list
         assign(_Ilist.begin(), _Ilist.end());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, void>::type vector< _Ty, _Alloc >::assign	(	_Iter	_First,
		_Iter	_Last
	)

inline

         {   // assign [_First, _Last)
         clear();
         _Assign(_First, _Last, _Iter_cat_t<_Iter>());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::assign	(	size_type	_Count,
		const value_type &	_Val
	)

inline

         {   // assign _Count * _Val
         clear();
         insert(begin(), _Count, _Val);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reference vector< _Ty, _Alloc >::at ( size_type _Pos ) const

inline

         {   // subscript nonmutable sequence with checking
         if (size() <= _Pos)
             _Xran();
         return (*(this->_Myfirst() + _Pos));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

reference vector< _Ty, _Alloc >::at ( size_type _Pos )

inline

         {   // subscript mutable sequence with checking
         if (size() <= _Pos)
             _Xran();
         return (*(this->_Myfirst() + _Pos));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

reference vector< _Ty, _Alloc >::back ( )

inline

         {   // return last element of mutable sequence
         return (*(end() - 1));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reference vector< _Ty, _Alloc >::back ( ) const

inline

         {   // return last element of nonmutable sequence
         return (*(end() - 1));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::begin ( )

inline

         {   // return iterator for beginning of mutable sequence
         return (iterator(this->_Myfirst(), &this->_Get_data()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator vector< _Ty, _Alloc >::begin ( ) const

inline

         {   // return iterator for beginning of nonmutable sequence
         return (const_iterator(this->_Myfirst(), &this->_Get_data()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

size_type vector< _Ty, _Alloc >::capacity ( ) const

inline

         {   // return current length of allocated storage
         return (this->_Myend() - this->_Myfirst());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator vector< _Ty, _Alloc >::cbegin ( ) const

inline

         {   // return iterator for beginning of nonmutable sequence
         return (begin());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator vector< _Ty, _Alloc >::cend ( ) const

inline

         {   // return iterator for end of nonmutable sequence
         return (end());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::clear ( )

inline

         {   // erase all
         this->_Orphan_all();
         _Destroy(this->_Myfirst(), this->_Mylast());
         this->_Mylast() = this->_Myfirst();
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reverse_iterator vector< _Ty, _Alloc >::crbegin ( ) const

inline

         {   // return iterator for beginning of reversed nonmutable sequence
         return (rbegin());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reverse_iterator vector< _Ty, _Alloc >::crend ( ) const

inline

         {   // return iterator for end of reversed nonmutable sequence
         return (rend());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

_Ty* vector< _Ty, _Alloc >::data ( )

inline

         {   // return address of first element
         return (_Unfancy(this->_Myfirst()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const _Ty* vector< _Ty, _Alloc >::data ( ) const

inline

         {   // return address of first element
         return (_Unfancy(this->_Myfirst()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class... _Valty>

iterator vector< _Ty, _Alloc >::emplace	(	const_iterator	_Where,
		_Valty &&...	_Val
	)

inline

         {   // insert by moving _Val at _Where
         size_type _Off = _VIPTR(_Where) - this->_Myfirst();
 
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (size() < _Off)
             _DEBUG_ERROR("vector emplace iterator outside range");
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
         emplace_back(_STD forward<_Valty>(_Val)...);
         _STD rotate(begin() + _Off, end() - 1, end());
         return (begin() + _Off);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class... _Valty>

void vector< _Ty, _Alloc >::emplace_back ( _Valty &&... _Val )

inline

         {   // insert by moving into element at end
         if (this->_Mylast() == this->_Myend())
             _Reserve(1);
         _Orphan_range(this->_Mylast(), this->_Mylast());
         this->_Getal().construct(_Unfancy(this->_Mylast()),
             _STD forward<_Valty>(_Val)...);
         ++this->_Mylast();
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

bool vector< _Ty, _Alloc >::empty ( ) const

inline

         {   // test if sequence is empty
         return (this->_Myfirst() == this->_Mylast());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::end ( )

inline

         {   // return iterator for end of mutable sequence
         return (iterator(this->_Mylast(), &this->_Get_data()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_iterator vector< _Ty, _Alloc >::end ( ) const

inline

         {   // return iterator for end of nonmutable sequence
         return (const_iterator(this->_Mylast(), &this->_Get_data()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::erase ( const_iterator _Where )

inline

         {   // erase element at where
         _Move_unchecked(_VIPTR(_Where) + 1, this->_Mylast(),
             _VIPTR(_Where));
         _Destroy(this->_Mylast() - 1, this->_Mylast());
         --this->_Mylast();
         return (_Make_iter(_Where));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::erase	(	const_iterator	_First_arg,
		const_iterator	_Last_arg
	)

inline

         {   // erase [_First, _Last)
         if (_First_arg == begin() && _Last_arg == end())
             clear();
         else if (_First_arg != _Last_arg)
             {   // clear partial
             iterator _First = _Make_iter(_First_arg);
             iterator _Last = _Make_iter(_Last_arg);
 
             if (_First != _Last)
                 {   // worth doing, copy down over hole
  #if _ITERATOR_DEBUG_LEVEL == 2
                 if (_Last < _First || _VICONT(_First) != &this->_Get_data()
                     || _VIPTR(_First) < this->_Myfirst()
                     || this->_Mylast() < _VIPTR(_Last))
                     _DEBUG_ERROR("vector erase iterator outside range");
                 pointer _Ptr = _Move_unchecked(_VIPTR(_Last), this->_Mylast(),
                     _VIPTR(_First));
                 _Orphan_range(_VIPTR(_First), this->_Mylast());
 
  #else /* _ITERATOR_DEBUG_LEVEL == 2 */
                 pointer _Ptr = _Move_unchecked(_VIPTR(_Last), this->_Mylast(),
                     _VIPTR(_First));
  #endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
                 _Destroy(_Ptr, this->_Mylast());
                 this->_Mylast() = _Ptr;
                 }
             }
         return (_Make_iter(_First_arg));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

reference vector< _Ty, _Alloc >::front ( )

inline

         {   // return first element of mutable sequence
         return (*begin());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reference vector< _Ty, _Alloc >::front ( ) const

inline

         {   // return first element of nonmutable sequence
         return (*begin());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

_Alloc vector< _Ty, _Alloc >::get_allocator ( ) const

inline

         {   // return allocator object for values
         _Alloc _Ret(this->_Getal());
         return (_Ret);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		_Ty &&	_Val
	)

inline

         {   // insert by moving _Val at _Where
         return (emplace(_Where, _STD move(_Val)));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		_XSTD initializer_list< value_type >	_Ilist
	)

inline

         {   // insert initializer_list
         return (insert(_Where, _Ilist.begin(), _Ilist.end()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		const _Ty &	_Val
	)

inline

         {   // insert _Val at _Where
         return (_Insert_n(_Where, (size_type)1, _Val));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

iterator vector< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		size_type	_Count,
		const _Ty &	_Val
	)

inline

         {   // insert _Count * _Val at _Where
         return (_Insert_n(_Where, _Count, _Val));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, iterator>::type vector< _Ty, _Alloc >::insert	(	const_iterator	_Where,
		_Iter	_First,
		_Iter	_Last
	)

inline

         {   // insert [_First, _Last) at _Where
         size_type _Off = _VIPTR(_Where) - this->_Myfirst();
         _Insert(_Where, _First, _Last, _Iter_cat_t<_Iter>());
         return (begin() + _Off);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

size_type vector< _Ty, _Alloc >::max_size ( ) const

inline

         {   // return maximum possible length of sequence
         return (this->_Getal().max_size());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

_Myt& vector< _Ty, _Alloc >::operator= ( _Myt && _Right )

inline

         {   // assign by moving _Right
         if (this != &_Right)
             {   // different, assign it
             _Tidy();
             if (_Alty::propagate_on_container_move_assignment::value
                 && this->_Getal() != _Right._Getal())
                 this->_Move_alloc(_Right._Getal());
 
             _Assign_rv(_STD forward<_Myt>(_Right));
             }
         return (*this);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

_Myt& vector< _Ty, _Alloc >::operator= ( _XSTD initializer_list< value_type > _Ilist )

inline

         {   // assign initializer_list
         assign(_Ilist.begin(), _Ilist.end());
         return (*this);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

_Myt& vector< _Ty, _Alloc >::operator= ( const _Myt & _Right )

inline

         {   // assign _Right
         if (this != &_Right)
             {   // different, assign it
             if (this->_Getal() != _Right._Getal()
                 && _Alty::propagate_on_container_copy_assignment::value)
                 {   // change allocator before copying
                 _Tidy();
                 this->_Copy_alloc(_Right._Getal());
                 }
 
             this->_Orphan_all();
 
             if (_Right.empty())
                 clear();    // new sequence empty, erase existing sequence
             else if (_Right.size() <= size())
                 {   // enough elements, copy new and destroy old
                 pointer _Ptr = _Copy_unchecked(_Right._Myfirst(),
                     _Right._Mylast(), this->_Myfirst());    // copy new
                 _Destroy(_Ptr, this->_Mylast());    // destroy old
                 this->_Mylast() = this->_Myfirst() + _Right.size();
                 }
             else if (_Right.size() <= capacity())
                 {   // enough room, copy and construct new
                 pointer _Ptr = _Right._Myfirst() + size();
                 _Copy_unchecked(_Right._Myfirst(),
                     _Ptr, this->_Myfirst());
                 this->_Mylast() = _Ucopy(_Ptr, _Right._Mylast(),
                     this->_Mylast());
                 }
             else
                 {   // not enough room, allocate new array and construct new
                 if (this->_Myfirst() != pointer())
                     {   // discard old array
                     _Destroy(this->_Myfirst(), this->_Mylast());
                     this->_Getal().deallocate(this->_Myfirst(),
                         this->_Myend() - this->_Myfirst());
                     }
                 if (_Buy(_Right.size()))
                     _TRY_BEGIN
                     this->_Mylast() =
                         _Ucopy(_Right._Myfirst(), _Right._Mylast(),
                         this->_Myfirst());
                     _CATCH_ALL
                     _Tidy();
                     _RERAISE;
                     _CATCH_END
                 }
             }
         return (*this);
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reference vector< _Ty, _Alloc >::operator[] ( size_type _Pos ) const

inline

         {   // subscript nonmutable sequence
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (size() <= _Pos)
             {   // report error
             _DEBUG_ERROR("vector subscript out of range");
             _SCL_SECURE_OUT_OF_RANGE;
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE_RANGE(_Pos < size());
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         return (*(this->_Myfirst() + _Pos));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

reference vector< _Ty, _Alloc >::operator[] ( size_type _Pos )

inline

         {   // subscript mutable sequence
  #if _ITERATOR_DEBUG_LEVEL == 2
         if (size() <= _Pos)
             {   // report error
             _DEBUG_ERROR("vector subscript out of range");
             _SCL_SECURE_OUT_OF_RANGE;
             }
 
  #elif _ITERATOR_DEBUG_LEVEL == 1
         _SCL_SECURE_VALIDATE_RANGE(_Pos < size());
  #endif /* _ITERATOR_DEBUG_LEVEL */
 
         return (*(this->_Myfirst() + _Pos));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::pop_back ( )

inline

         {   // erase element at end
         this->_Getal().destroy(_Unfancy(this->_Mylast() - 1));
         --this->_Mylast();
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::push_back ( value_type && _Val )

inline

         {   // insert by moving into element at end
         if (_Inside(_STD addressof(_Val)))
             {   // push back an element
             size_type _Idx = _STD addressof(_Val) - _Unfancy(this->_Myfirst());
             if (this->_Mylast() == this->_Myend())
                 _Reserve(1);
             _Orphan_range(this->_Mylast(), this->_Mylast());
             this->_Getal().construct(_Unfancy(this->_Mylast()),
                 _STD forward<value_type>(this->_Myfirst()[_Idx]));
             ++this->_Mylast();
             }
         else
             {   // push back a non-element
             if (this->_Mylast() == this->_Myend())
                 _Reserve(1);
             _Orphan_range(this->_Mylast(), this->_Mylast());
             this->_Getal().construct(_Unfancy(this->_Mylast()),
                 _STD forward<value_type>(_Val));
             ++this->_Mylast();
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::push_back ( const value_type & _Val )

inline

         {   // insert element at end
         if (_Inside(_STD addressof(_Val)))
             {   // push back an element
             size_type _Idx = _STD addressof(_Val) - _Unfancy(this->_Myfirst());
             if (this->_Mylast() == this->_Myend())
                 _Reserve(1);
             _Orphan_range(this->_Mylast(), this->_Mylast());
             this->_Getal().construct(_Unfancy(this->_Mylast()),
                 this->_Myfirst()[_Idx]);
             ++this->_Mylast();
             }
         else
             {   // push back a non-element
             if (this->_Mylast() == this->_Myend())
                 _Reserve(1);
             _Orphan_range(this->_Mylast(), this->_Mylast());
             this->_Getal().construct(_Unfancy(this->_Mylast()),
                 _Val);
             ++this->_Mylast();
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

reverse_iterator vector< _Ty, _Alloc >::rbegin ( )

inline

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

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reverse_iterator vector< _Ty, _Alloc >::rbegin ( ) const

inline

         {   // return iterator for beginning of reversed nonmutable sequence
         return (const_reverse_iterator(end()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

reverse_iterator vector< _Ty, _Alloc >::rend ( )

inline

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

template<class _Ty, class _Alloc = allocator<_Ty>>

const_reverse_iterator vector< _Ty, _Alloc >::rend ( ) const

inline

         {   // return iterator for end of reversed nonmutable sequence
         return (const_reverse_iterator(begin()));
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::reserve ( size_type _Count )

inline

         {   // determine new minimum length of allocated storage
         if (capacity() < _Count)
             {   // something to do, check and reallocate
             if (max_size() < _Count)
                 _Xlen();
             _Reallocate(_Count);
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::resize ( size_type _Newsize )

inline

         {   // determine new length, padding as needed
         if (_Newsize < size())
             _Pop_back_n(size() - _Newsize);
         else if (size() < _Newsize)
             {   // pad as needed
             _Reserve(_Newsize - size());
             _TRY_BEGIN
             _Uninitialized_default_fill_n(this->_Mylast(), _Newsize - size(),
                 this->_Getal());
             _CATCH_ALL
             _Tidy();
             _RERAISE;
             _CATCH_END
             this->_Mylast() += _Newsize - size();
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::resize	(	size_type	_Newsize,
		const value_type &	_Val
	)

inline

         {   // determine new length, padding with _Val elements as needed
         if (_Newsize < size())
             _Pop_back_n(size() - _Newsize);
         else if (size() < _Newsize)
             {   // pad as needed
             const value_type *_Ptr = _STD addressof(_Val);
 
             if (_Inside(_Ptr))
                 {   // padding is inside vector, recompute _Ptr after reserve
                 const difference_type _Idx = _Ptr
                     - _Unfancy(this->_Myfirst());
                 _Reserve(_Newsize - size());
                 _Ptr = _Unfancy(this->_Myfirst()) + _Idx;
                 }
             else
                 _Reserve(_Newsize - size());
 
             _TRY_BEGIN
             _Ufill(this->_Mylast(), _Newsize - size(), _Ptr);
             _CATCH_ALL
             _Tidy();
             _RERAISE;
             _CATCH_END
             this->_Mylast() += _Newsize - size();
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::shrink_to_fit ( )

inline

         {   // reduce capacity
         if (_Has_unused_capacity())
             {   // worth shrinking, do it
             if (empty())
                 _Tidy();
             else
                 _Reallocate(size());
             }
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

size_type vector< _Ty, _Alloc >::size ( ) const

inline

         {   // return length of sequence
         return (this->_Mylast() - this->_Myfirst());
         }

template<class _Ty, class _Alloc = allocator<_Ty>>

void vector< _Ty, _Alloc >::swap ( _Myt & _Right )

inline

         {   // exchange contents with _Right
         if (this != &_Right)
             {   // (maybe) swap allocators, swap control information
             _Pocs(this->_Getal(), _Right._Getal());
             this->_Swap_all(_Right);
             _Swap_adl(this->_Myfirst(), _Right._Myfirst());
             _Swap_adl(this->_Mylast(), _Right._Mylast());
             _Swap_adl(this->_Myend(), _Right._Myend());
             }
         }

The documentation for this class was generated from the following file:

VS2015/inc/vector