vector< _Ty, _Alloc > Class Template Reference

Inheritance diagram for vector< _Ty, _Alloc >:

Public Types
typedef vector< _Ty, _Alloc >	_Myt
typedef _Vector_alloc<!is_empty< _Alloc >::value, _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<!is_empty< _Alloc >::value, _Vec_base_types< _Ty, _Alloc > >
typedef _Vector_alloc< _Al_has_storage, _Vec_base_types< _Ty, _Alloc > >	_Myt
typedef _Vec_base_types< _Ty, _Alloc >::_Alloc	_Alloc
typedef _Vec_base_types< _Ty, _Alloc >::_Alty	_Alty
Public Types inherited from _Vector_val< _Vec_base_types< _Ty, _Alloc >::_Val_types >
typedef _Vector_val< _Vec_base_types< _Ty, _Alloc >::_Val_types >	_Myt
typedef _Vec_base_types< _Ty, _Alloc >::_Val_types::value_type	value_type
typedef _Vec_base_types< _Ty, _Alloc >::_Val_types::size_type	size_type
typedef _Vec_base_types< _Ty, _Alloc >::_Val_types::difference_type	difference_type
typedef _Vec_base_types< _Ty, _Alloc >::_Val_types::pointer	pointer
typedef _Vec_base_types< _Ty, _Alloc >::_Val_types::const_pointer	const_pointer
typedef _Vec_base_types< _Ty, _Alloc >::_Val_types::reference	reference
typedef _Vec_base_types< _Ty, _Alloc >::_Val_types::const_reference	const_reference
typedef _Vector_iterator< _Myt >	iterator
typedef _Vector_const_iterator< _Myt >	const_iterator

Public Member Functions
	vector ()
	vector (const _Alloc &_Al)
	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)
	vector (_Myt &&_Right, const _Alloc &_Al)
_Myt &	operator= (_Myt &&_Right)
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)
pointer	data () _NOEXCEPT
const_pointer	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)
Public Member Functions inherited from _Vector_alloc<!is_empty< _Alloc >::value, _Vec_base_types< _Ty, _Alloc > >
	_Vector_alloc (const _Alloc &_Al=_Alloc())
void	_Change_alloc (const _Alty &_Al)
void	_Swap_alloc (_Myt &_Right)
_Alty &	_Getal ()
const _Alty &	_Getal () const
Public Member Functions inherited from _Vector_val< _Vec_base_types< _Ty, _Alloc >::_Val_types >
	_Vector_val ()
Public Member Functions inherited from _Container_base0
void	_Orphan_all ()
void	_Swap_all (_Container_base0 &)

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)
	__declspec (noreturn) void _Xlen() const
	__declspec (noreturn) void _Xran() const
void	_Orphan_range (pointer, pointer) const

Additional Inherited Members
Public Attributes inherited from _Vector_alloc<!is_empty< _Alloc >::value, _Vec_base_types< _Ty, _Alloc > >
_Vec_base_types< _Ty, _Alloc >::_Alty	_Alval
Public Attributes inherited from _Vector_val< _Vec_base_types< _Ty, _Alloc >::_Val_types >
pointer	_Myfirst
pointer	_Mylast
pointer	_Myend

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<!is_empty<_Alloc>::value, _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
            _Alty _Alval(this->_Getal());
            _TRY_BEGIN
            _Uninitialized_default_fill_n(this->_Myfirst, _Count, _Alval);
            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(_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
        insert(begin(), _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>>

vector< _Ty, _Alloc >::__declspec ( noreturn  ) const

inlineprotected

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

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

vector< _Ty, _Alloc >::__declspec ( noreturn  ) const

inlineprotected

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

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
        if (_First == _Last)
            return; // nothing to do

        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(_First));
        }

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
        _Alty _Alval(this->_Getal());
        _Destroy_range(_First, _Last, _Alval);
        }

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
            || _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 = 0;
        _Distance(_First, _Last, _Count);

        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
            || _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);
            _Copy_backward(_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 < this->_Mylast && 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));
        }

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

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

inlineprotected

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

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
        _Alty _Alval(this->_Getal());
        return (_Uninitialized_copy(_First, _Last,
            _Ptr, _Alval));
        }

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
        _Alty _Alval(this->_Getal());
        _Uninitialized_fill_n(_Ptr, _Count, _Pval, _Alval);
        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
        _Alty _Alval(this->_Getal());
        return (_Uninitialized_move(_First, _Last,
            _Ptr, _Alval));
        }

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 >::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(_First));
        }

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));
        }

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));
        }

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 (((const _Myt *)this)->begin());
        }

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

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

inline

        {   // return iterator for end of nonmutable sequence
        return (((const _Myt *)this)->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 (((const _Myt *)this)->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 (((const _Myt *)this)->rend());
        }

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

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

inline

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

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

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

inline

        {   // return address of first element
        return (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(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));
        }

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));
        }

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

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

inline

        {   // erase element at where
        _Move(_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
                    || _VIPTR(_First) < this->_Myfirst
                    || this->_Mylast < _VIPTR(_Last))
                    _DEBUG_ERROR("vector erase iterator outside range");
                pointer _Ptr = _Move(_VIPTR(_Last), this->_Mylast,
                    _VIPTR(_First));
                _Orphan_range(_VIPTR(_First), this->_Mylast);

 #else /* _ITERATOR_DEBUG_LEVEL == 2 */
                pointer _Ptr = _Move(_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
        return (this->_Getal());
        }

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(_First));
        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->_Change_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->_Change_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_impl(_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_impl(_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(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) - this->_Myfirst;
            if (this->_Mylast == this->_Myend)
                _Reserve(1);
            _Orphan_range(this->_Mylast, this->_Mylast);
            this->_Getal().construct(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(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) - this->_Myfirst;
            if (this->_Mylast == this->_Myend)
                _Reserve(1);
            _Orphan_range(this->_Mylast, this->_Mylast);
            this->_Getal().construct(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(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
            _Alty _Alval(this->_Getal());
            _Reserve(_Newsize - size());
            _TRY_BEGIN
            _Uninitialized_default_fill_n(this->_Mylast, _Newsize - size(),
                _Alval);
            _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
                    - _STD addressof(*this->_Myfirst);
                _Reserve(_Newsize - size());
                _Ptr = _STD addressof(*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)
            ;   // same object, do nothing
        else if (this->_Getal() == _Right._Getal())
            {   // same allocator, swap control information
            this->_Swap_all(_Right);
            _Swap_adl(this->_Myfirst, _Right._Myfirst);
            _Swap_adl(this->_Mylast, _Right._Mylast);
            _Swap_adl(this->_Myend, _Right._Myend);
            }

        else if (_Alty::propagate_on_container_swap::value)
            {   // swap allocators and control information
            this->_Swap_alloc(_Right);
            _Swap_adl(this->_Myfirst, _Right._Myfirst);
            _Swap_adl(this->_Mylast, _Right._Mylast);
            _Swap_adl(this->_Myend, _Right._Myend);
            }

        else
            {   // containers are incompatible
 #if _ITERATOR_DEBUG_LEVEL == 2
            _DEBUG_ERROR("vector containers incompatible for swap");

 #else /* ITERATOR_DEBUG_LEVEL == 2 */
            _XSTD terminate();
 #endif /* ITERATOR_DEBUG_LEVEL == 2 */
            }
        }

---

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

• VS2013/inc/vector