vector< _Ty, _Alloc > Class Template Reference

Inheritance diagram for vector< _Ty, _Alloc >:

Public Types
typedef _Ty	value_type
typedef _Alloc	allocator_type
typedef _Mybase::pointer	pointer
typedef _Mybase::const_pointer	const_pointer
typedef _Ty &	reference
typedef const _Ty &	const_reference
typedef _Mybase::size_type	size_type
typedef _Mybase::difference_type	difference_type
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::size_type	size_type
typedef _Val_types::difference_type	difference_type
typedef _Val_types::pointer	pointer
typedef _Val_types::const_pointer	const_pointer
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 (_CRT_GUARDOVERFLOW const size_type _Count, const _Alloc &_Al=_Alloc())
	vector (_CRT_GUARDOVERFLOW const size_type _Count, const _Ty &_Val, const _Alloc &_Al=_Alloc())
template<class _Iter , class = enable_if_t<_Is_iterator<_Iter>::value>>
	vector (_Iter _First, _Iter _Last, const _Alloc &_Al=_Alloc())
	vector (initializer_list< _Ty > _Ilist, const _Alloc &_Al=_Alloc())
	vector (const vector &_Right)
	vector (const vector &_Right, const _Alloc &_Al)
	vector (vector &&_Right) _NOEXCEPT
	vector (vector &&_Right, const _Alloc &_Al)
vector &	operator= (vector &&_Right) _NOEXCEPT_OP(_Alty
	~vector () _NOEXCEPT
template<class... _Valty>
void	emplace_back (_Valty &&..._Val)
void	push_back (const _Ty &_Val)
void	push_back (_Ty &&_Val)
template<class... _Valty>
iterator	emplace (const_iterator _Where, _Valty &&..._Val)
iterator	insert (const_iterator _Where, const _Ty &_Val)
iterator	insert (const_iterator _Where, _Ty &&_Val)
iterator	insert (const_iterator _Where, _CRT_GUARDOVERFLOW const size_type _Count, const _Ty &_Val)
template<class _Iter >
enable_if_t< _Is_iterator< _Iter >::value, iterator >	insert (const_iterator _Where, _Iter _First, _Iter _Last)
iterator	insert (const_iterator _Where, initializer_list< _Ty > _Ilist)
void	assign (_CRT_GUARDOVERFLOW const size_type _Newsize, const _Ty &_Val)
template<class _Iter >
enable_if_t< _Is_iterator< _Iter >::value, void >	assign (_Iter _First, _Iter _Last)
void	assign (initializer_list< _Ty > _Ilist)
vector &	operator= (const vector &_Right)
vector &	operator= (initializer_list< _Ty > _Ilist)
void	resize (_CRT_GUARDOVERFLOW const size_type _Newsize)
void	resize (_CRT_GUARDOVERFLOW const size_type _Newsize, const _Ty &_Val)
void	reserve (_CRT_GUARDOVERFLOW const size_type _Newcapacity)
void	shrink_to_fit ()
void	pop_back ()
iterator	erase (const_iterator _Where)
iterator	erase (const_iterator _First, const_iterator _Last)
void	clear () _NOEXCEPT
void	swap (vector &_Right) _NOEXCEPT_OP(_Alty
_Ty *	data () _NOEXCEPT
const _Ty *	data () const _NOEXCEPT
iterator	begin () _NOEXCEPT
const_iterator	begin () const _NOEXCEPT
iterator	end () _NOEXCEPT
const_iterator	end () const _NOEXCEPT
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
bool	empty () const _NOEXCEPT
size_type	size () const _NOEXCEPT
size_type	max_size () const _NOEXCEPT
size_type	capacity () const _NOEXCEPT
_Ty &	operator[] (const size_type _Pos)
const _Ty &	operator[] (const size_type _Pos) const
_Ty &	at (const size_type _Pos)
const _Ty &	at (const size_type _Pos) const
_Ty &	front ()
const _Ty &	front () const
_Ty &	back ()
const _Ty &	back () const
_Alloc	get_allocator () const _NOEXCEPT
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

Private Types
typedef _Vector_alloc< _Vec_base_types< _Ty, _Alloc > >	_Mybase
typedef _Mybase::_Alty	_Alty

Private Member Functions
template<class _Iter >
void	_Range_construct_or_tidy (_Iter _First, _Iter _Last, input_iterator_tag)
template<class _Iter >
void	_Range_construct_or_tidy (_Iter _First, _Iter _Last, forward_iterator_tag)
void	_Move_from (vector &&_Right, true_type)
void	_Move_from (vector &&_Right, false_type)
template<class... _Valty>
void	_Emplace_back_with_unused_capacity (_Valty &&..._Val)
template<class _Iter >
void	_Insert_range (const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag)
template<class _Iter >
void	_Insert_range (const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag)
template<class _Iter >
void	_Assign_range (_Iter _First, _Iter _Last, input_iterator_tag)
template<class _Iter >
void	_Assign_range (_Iter _First, _Iter _Last, forward_iterator_tag)
template<class _Lambda >
void	_Resize (const size_type _Newsize, _Lambda _Udefault_or_fill)
void	_Reallocate_exactly (const size_type _Newcapacity)
size_type	_Unused_capacity () const _NOEXCEPT
bool	_Has_unused_capacity () const _NOEXCEPT
pointer	_Udefault (pointer _Dest, const size_type _Count)
pointer	_Ufill (pointer _Dest, const size_type _Count, const _Ty &_Val)
template<class _Iter >
pointer	_Ucopy (_Iter _First, _Iter _Last, pointer _Dest)
pointer	_Umove (pointer _First, pointer _Last, pointer _Dest)
void	_Umove_if_noexcept1 (pointer _First, pointer _Last, pointer _Dest, true_type)
void	_Umove_if_noexcept1 (pointer _First, pointer _Last, pointer _Dest, false_type)
void	_Umove_if_noexcept (pointer _First, pointer _Last, pointer _Dest)
void	_Destroy (pointer _First, pointer _Last)
size_type	_Calculate_growth (const size_type _Newsize) const
bool	_Buy (const size_type _Newcapacity)
void	_Change_array (const pointer _Newvec, const size_type _Newsize, const size_type _Newcapacity)
void	_Tidy ()
void	_Orphan_range (pointer, pointer) const

Static Private Member Functions
static void	_Xlength ()
static void	_Xrange ()

Member Typedef Documentation

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

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

private

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

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

private

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 const _Ty& 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 _Ty& 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 _Ty 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 ( _CRT_GUARDOVERFLOW const size_type  _Count, const _Alloc &  _Al = _Alloc()  )

inlineexplicit

        : _Mybase(_Al)
        {   // construct from _Count * _Ty(), optional allocator
        if (_Buy(_Count))
            {   // nonzero, fill it
            _TRY_BEGIN
            this->_Mylast() = _Udefault(this->_Myfirst(), _Count);
            _CATCH_ALL
            _Tidy();
            _RERAISE;
            _CATCH_END
            }
        }

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

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

inline

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

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

template<class _Iter , class = enable_if_t<_Is_iterator<_Iter>::value>>

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

inline

        : _Mybase(_Al)
        {   // construct from [_First, _Last) with optional allocator
        _DEBUG_RANGE(_First, _Last);
        _Range_construct_or_tidy(_Unchecked(_First), _Unchecked(_Last), _Iter_cat_t<_Iter>{});
        }

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

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

inline

        : _Mybase(_Al)
        {   // construct from initializer_list, optional allocator
        _Range_construct_or_tidy(_Ilist.begin(), _Ilist.end(), random_access_iterator_tag{});
        }

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

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

inline

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

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

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

inline

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

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

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

inline

        : _Mybase(_STD move(_Right._Getal()))
        {   // construct by moving _Right
        _Move_from(_STD move(_Right), true_type{});
        }

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

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

inline

        : _Mybase(_Al)
        {   // construct by moving _Right, allocator
        _TRY_BEGIN
        // performance note: partially unnecessary EH machinery for stateful allocators
        _Move_from(_STD move(_Right), typename _Alty::is_always_equal{});
        _CATCH_ALL
        _Tidy();
        _RERAISE;
        _CATCH_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_range ( _Iter  _First, _Iter  _Last, input_iterator_tag    )

inlineprivate

        {   // assign [_First, _Last), input iterators
        this->_Orphan_all();

        pointer _Next = this->_Myfirst();

        for (; _First != _Last && _Next != this->_Mylast(); ++_First, (void)++_Next)
            {
            *_Next = *_First;
            }

        // Code size optimization: we've exhausted only the source, only the dest, or both.
        // If we've exhausted only the source: we Trim, then Append does nothing.
        // If we've exhausted only the dest: Trim does nothing, then we Append.
        // If we've exhausted both: Trim does nothing, then Append does nothing.

        // Trim.
        _Destroy(_Next, this->_Mylast());
        this->_Mylast() = _Next;

        // Append.
        for (; _First != _Last; ++_First)
            {
            emplace_back(*_First);  // performance note: emplace_back()'s strong guarantee is unnecessary here
            }
        }

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

template<class _Iter >

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

inlineprivate

        {   // assign [_First, _Last), forward iterators
        const size_type _Newsize = _STD distance(_First, _Last);

        this->_Orphan_all();

        const size_type _Oldsize = size();
        const size_type _Oldcapacity = capacity();

        if (_Newsize > _Oldcapacity)
            {   // reallocate
            if (_Newsize > max_size())
                {
                _Xlength();
                }

            const size_type _Newcapacity = _Calculate_growth(_Newsize);

            if (this->_Myfirst() != pointer())
                {   // destroy and deallocate old array
                _Destroy(this->_Myfirst(), this->_Mylast());
                this->_Getal().deallocate(this->_Myfirst(), _Oldcapacity);
                }

            _Buy(_Newcapacity);

            this->_Mylast() = _Ucopy(_First, _Last, this->_Myfirst());
            }
        else if (_Newsize > _Oldsize)
            {
            const _Iter _Mid = _STD next(_First, _Oldsize); // performance note: traversing [_First, _Mid) twice
            _Copy_unchecked(_First, _Mid, this->_Myfirst());
            this->_Mylast() = _Ucopy(_Mid, _Last, this->_Mylast());
            }
        else
            {
            const pointer _Newlast = this->_Myfirst() + _Newsize;
            _Copy_unchecked(_First, _Last, this->_Myfirst());
            _Destroy(_Newlast, this->_Mylast());
            this->_Mylast() = _Newlast;
            }
        }

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

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

inlineprivate

        {   // allocate array with _Newcapacity elements
        this->_Myfirst() = pointer();
        this->_Mylast() = pointer();
        this->_Myend() = pointer();

        if (_Newcapacity == 0)
            {
            return (false);
            }

        if (_Newcapacity > max_size())
            {
            _Xlength();
            }

        this->_Myfirst() = this->_Getal().allocate(_Newcapacity);
        this->_Mylast() = this->_Myfirst();
        this->_Myend() = this->_Myfirst() + _Newcapacity;

        return (true);
        }

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

size_type vector< _Ty, _Alloc >::_Calculate_growth ( const size_type  _Newsize ) const

inlineprivate

        {   // given _Oldcapacity and _Newsize, calculate geometric growth
        const size_type _Oldcapacity = capacity();

        if (_Oldcapacity > max_size() - _Oldcapacity / 2)
            {
            return (_Newsize);  // geometric growth would overflow
            }

        const size_type _Geometric = _Oldcapacity + _Oldcapacity / 2;

        if (_Geometric < _Newsize)
            {
            return (_Newsize);  // geometric growth would be insufficient
            }

        return (_Geometric);    // geometric growth is sufficient
        }

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

void vector< _Ty, _Alloc >::_Change_array ( const pointer  _Newvec, const size_type  _Newsize, const size_type  _Newcapacity  )

inlineprivate

        {   // orphan all iterators, discard old array, acquire new array
        this->_Orphan_all();

        if (this->_Myfirst() != pointer())
            {   // destroy and deallocate old array
            _Destroy(this->_Myfirst(), this->_Mylast());
            this->_Getal().deallocate(this->_Myfirst(), this->_Myend() - this->_Myfirst());
            }

        this->_Myfirst() = _Newvec;
        this->_Mylast() = _Newvec + _Newsize;
        this->_Myend() = _Newvec + _Newcapacity;
        }

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

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

inlineprivate

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

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

template<class... _Valty>

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

inlineprivate

        {   // insert by perfectly forwarding into element at end, provide strong guarantee
            // Pre: _Has_unused_capacity()
        this->_Getal().construct(_Unfancy(this->_Mylast()), _STD forward<_Valty>(_Val)...);
        _Orphan_range(this->_Mylast(), this->_Mylast());
        ++this->_Mylast();
        }

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

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

inlineprivate

        {   // 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_range ( const_iterator  _Where, _Iter  _First, _Iter  _Last, input_iterator_tag    )

inlineprivate

        {   // insert [_First, _Last) at _Where, input iterators
        if (_First == _Last)
            {
            return; // nothing to do, avoid invalidating iterators
            }

        const size_type _Whereoff = _Where._Ptr - this->_Myfirst();
        const size_type _Oldsize = size();

        // For one-at-back, provide strong guarantee.
        // Otherwise, provide basic guarantee (despite N4606 23.3.11.5 [vector.modifiers]/1).
        // Performance note: except for one-at-back, emplace_back()'s strong guarantee is unnecessary here.

        for (; _First != _Last; ++_First)
            {
            emplace_back(*_First);
            }

        _Orphan_range(this->_Myfirst() + _Whereoff, this->_Myfirst() + _Oldsize);

        _Rotate_unchecked(this->_Myfirst() + _Whereoff, this->_Myfirst() + _Oldsize, this->_Mylast());
        }

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

template<class _Iter >

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

inlineprivate

        {   // insert [_First, _Last) at _Where, forward iterators
        const size_type _Count = _STD distance(_First, _Last);
        const size_type _Whereoff = _Where._Ptr - this->_Myfirst();
        const bool _One_at_back = _Count == 1 && _Where._Ptr == this->_Mylast();

        if (_Count == 0)
            {   // nothing to do, avoid invalidating iterators
            }
        else if (_Count > _Unused_capacity())
            {   // reallocate
            const size_type _Oldsize = size();

            if (_Count > max_size() - _Oldsize)
                {
                _Xlength();
                }

            const size_type _Newsize = _Oldsize + _Count;
            const size_type _Newcapacity = _Calculate_growth(_Newsize);

            const pointer _Newvec = this->_Getal().allocate(_Newcapacity);
            const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
            pointer _Constructed_first = _Constructed_last;

            _TRY_BEGIN
            _Ucopy(_First, _Last, _Newvec + _Whereoff);
            _Constructed_first = _Newvec + _Whereoff;

            if (_One_at_back)
                {   // provide strong guarantee
                _Umove_if_noexcept(this->_Myfirst(), this->_Mylast(), _Newvec);
                }
            else
                {   // provide basic guarantee
                _Umove(this->_Myfirst(), _Where._Ptr, _Newvec);
                _Constructed_first = _Newvec;
                _Umove(_Where._Ptr, this->_Mylast(), _Newvec + _Whereoff + _Count);
                }
            _CATCH_ALL
            _Destroy(_Constructed_first, _Constructed_last);
            this->_Getal().deallocate(_Newvec, _Newcapacity);
            _RERAISE;
            _CATCH_END

            _Change_array(_Newvec, _Newsize, _Newcapacity);
            }
        else
            {   // Attempt to provide the strong guarantee for EmplaceConstructible failure.
                // If we encounter copy/move construction/assignment failure, provide the basic guarantee.
                // (For one-at-back, this provides the strong guarantee.)

            const pointer _Oldlast = this->_Mylast();
            const size_type _Affected_elements = _Oldlast - _Where._Ptr;

            if (_Count < _Affected_elements)
                {   // some affected elements must be assigned
                this->_Mylast() = _Umove(_Oldlast - _Count, _Oldlast, _Oldlast);
                _Move_backward_unchecked(_Where._Ptr, _Oldlast - _Count, _Oldlast);
                _Destroy(_Where._Ptr, _Where._Ptr + _Count);

                _TRY_BEGIN
                _Ucopy(_First, _Last, _Where._Ptr);
                _CATCH_ALL
                // glue the broken pieces back together

                    _TRY_BEGIN
                    _Umove(_Where._Ptr + _Count, _Where._Ptr + 2 * _Count, _Where._Ptr);
                    _CATCH_ALL
                    // vaporize the detached piece
                    _Orphan_range(_Where._Ptr, _Oldlast);
                    _Destroy(_Where._Ptr + _Count, this->_Mylast());
                    this->_Mylast() = _Where._Ptr;
                    _RERAISE;
                    _CATCH_END

                    _Move_unchecked(_Where._Ptr + 2 * _Count, this->_Mylast(), _Where._Ptr + _Count);
                    _Destroy(_Oldlast, this->_Mylast());
                    this->_Mylast() = _Oldlast;
                _RERAISE;
                _CATCH_END
                }
            else
                {   // affected elements don't overlap before/after
                const pointer _Relocated = _Where._Ptr + _Count;
                this->_Mylast() = _Umove(_Where._Ptr, _Oldlast, _Relocated);
                _Destroy(_Where._Ptr, _Oldlast);

                _TRY_BEGIN
                _Ucopy(_First, _Last, _Where._Ptr);
                _CATCH_ALL
                // glue the broken pieces back together

                    _TRY_BEGIN
                    _Umove(_Relocated, this->_Mylast(), _Where._Ptr);
                    _CATCH_ALL
                    // vaporize the detached piece
                    _Orphan_range(_Where._Ptr, _Oldlast);
                    _Destroy(_Relocated, this->_Mylast());
                    this->_Mylast() = _Where._Ptr;
                    _RERAISE;
                    _CATCH_END

                    _Destroy(_Relocated, this->_Mylast());
                    this->_Mylast() = _Oldlast;
                _RERAISE;
                _CATCH_END
                }

            _Orphan_range(_Where._Ptr, _Oldlast);
            }
        }

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

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

inlineprivate

        {   // move from _Right, stealing its contents
        this->_Swap_all(_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 >::_Move_from ( vector< _Ty, _Alloc > &&  _Right, false_type    )

inlineprivate

        {   // move from _Right, possibly moving its contents
        if (this->_Getal() == _Right._Getal())
            {
            _Move_from(_STD move(_Right), true_type{});
            }
        else if (_Buy(_Right.size()))
            {   // nonzero, fill it
            this->_Mylast() = _Umove(_Right._Myfirst(), _Right._Mylast(), this->_Myfirst());
            }
        }

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

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

inlineprivate

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

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

template<class _Iter >

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

inlineprivate

        {   // initialize with [_First, _Last), avoid leaking, input iterators
        _TRY_BEGIN
        for (; _First != _Last; ++_First)
            {
            emplace_back(*_First);  // performance note: emplace_back()'s strong guarantee is unnecessary here
            }
        _CATCH_ALL
        _Tidy();
        _RERAISE;
        _CATCH_END
        }

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

template<class _Iter >

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

inlineprivate

        {   // initialize with [_First, _Last), avoid leaking, 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 >::_Reallocate_exactly ( const size_type  _Newcapacity )

inlineprivate

        {   // set capacity to _Newcapacity (without geometric growth), provide strong guarantee
        const size_type _Size = size();

        const pointer _Newvec = this->_Getal().allocate(_Newcapacity);

        _TRY_BEGIN
        _Umove_if_noexcept(this->_Myfirst(), this->_Mylast(), _Newvec);
        _CATCH_ALL
        this->_Getal().deallocate(_Newvec, _Newcapacity);
        _RERAISE;
        _CATCH_END

        _Change_array(_Newvec, _Size, _Newcapacity);
        }

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

template<class _Lambda >

void vector< _Ty, _Alloc >::_Resize ( const size_type  _Newsize, _Lambda  _Udefault_or_fill  )

inlineprivate

        {   // trim or append elements, provide strong guarantee
        const size_type _Oldsize = size();
        const size_type _Oldcapacity = capacity();

        if (_Newsize > _Oldcapacity)
            {   // reallocate
            if (_Newsize > max_size())
                {
                _Xlength();
                }

            const size_type _Newcapacity = _Calculate_growth(_Newsize);

            const pointer _Newvec = this->_Getal().allocate(_Newcapacity);
            const pointer _Appended_first = _Newvec + _Oldsize;
            pointer _Appended_last = _Appended_first;

            _TRY_BEGIN
            _Appended_last = _Udefault_or_fill(_Appended_first, _Newsize - _Oldsize);
            _Umove_if_noexcept(this->_Myfirst(), this->_Mylast(), _Newvec);
            _CATCH_ALL
            _Destroy(_Appended_first, _Appended_last);
            this->_Getal().deallocate(_Newvec, _Newcapacity);
            _RERAISE;
            _CATCH_END

            _Change_array(_Newvec, _Newsize, _Newcapacity);
            }
        else if (_Newsize > _Oldsize)
            {   // append
            const pointer _Oldlast = this->_Mylast();
            this->_Mylast() = _Udefault_or_fill(_Oldlast, _Newsize - _Oldsize);
            _Orphan_range(_Oldlast, _Oldlast);
            }
        else if (_Newsize == _Oldsize)
            {   // nothing to do, avoid invalidating iterators
            }
        else
            {   // trim
            const pointer _Newlast = this->_Myfirst() + _Newsize;
            _Orphan_range(_Newlast, this->_Mylast());
            _Destroy(_Newlast, this->_Mylast());
            this->_Mylast() = _Newlast;
            }
        }

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

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

inlineprivate

        {   // free all storage
        this->_Orphan_all();

        if (this->_Myfirst() != pointer())
            {   // destroy and deallocate old array
            _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  _Dest  )

inlineprivate

        {   // copy [_First, _Last) to raw _Dest, using allocator
        return (_Uninitialized_copy(_First, _Last, _Dest, this->_Getal()));
        }

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

pointer vector< _Ty, _Alloc >::_Udefault ( pointer  _Dest, const size_type  _Count  )

inlineprivate

        {   // fill raw _Dest with _Count value-initialized objects, using allocator
        return (_Uninitialized_default_fill_n(_Dest, _Count, this->_Getal()));
        }

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

pointer vector< _Ty, _Alloc >::_Ufill ( pointer  _Dest, const size_type  _Count, const _Ty &  _Val  )

inlineprivate

        {   // fill raw _Dest with _Count copies of _Val, using allocator
        return (_Uninitialized_fill_n(_Dest, _Count, _Val, this->_Getal()));
        }

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

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

inlineprivate

        {   // move [_First, _Last) to raw _Dest, using allocator
        return (_Uninitialized_move(_First, _Last, _Dest, this->_Getal()));
        }

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

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

inlineprivate

        {   // move_if_noexcept [_First, _Last) to raw _Dest, using allocator
        _Umove_if_noexcept1(_First, _Last, _Dest,
            _Disjunction_t<is_nothrow_move_constructible<_Ty>, negation<is_copy_constructible<_Ty>>>{});
        }

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

void vector< _Ty, _Alloc >::_Umove_if_noexcept1 ( pointer  _First, pointer  _Last, pointer  _Dest, true_type    )

inlineprivate

        {   // move [_First, _Last) to raw _Dest, using allocator
        _Uninitialized_move(_First, _Last, _Dest, this->_Getal());
        }

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

void vector< _Ty, _Alloc >::_Umove_if_noexcept1 ( pointer  _First, pointer  _Last, pointer  _Dest, false_type    )

inlineprivate

        {   // copy [_First, _Last) to raw _Dest, using allocator
        _Uninitialized_copy(_First, _Last, _Dest, this->_Getal());
        }

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

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

inlineprivate

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

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

static void vector< _Ty, _Alloc >::_Xlength ( )

inlinestaticprivate

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

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

static void vector< _Ty, _Alloc >::_Xrange ( )

inlinestaticprivate

        {   // 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 ( _CRT_GUARDOVERFLOW const size_type  _Newsize, const _Ty &  _Val  )

inline

        {   // assign _Newsize * _Val
        this->_Orphan_all();

        const size_type _Oldsize = size();
        const size_type _Oldcapacity = capacity();

        if (_Newsize > _Oldcapacity)
            {   // reallocate
            if (_Newsize > max_size())
                {
                _Xlength();
                }

            const size_type _Newcapacity = _Calculate_growth(_Newsize);

            if (this->_Myfirst() != pointer())
                {   // destroy and deallocate old array
                _Destroy(this->_Myfirst(), this->_Mylast());
                this->_Getal().deallocate(this->_Myfirst(), _Oldcapacity);
                }

            _Buy(_Newcapacity);

            this->_Mylast() = _Ufill(this->_Myfirst(), _Newsize, _Val);
            }
        else if (_Newsize > _Oldsize)
            {
            _Fill_unchecked(this->_Myfirst(), this->_Mylast(), _Val);
            this->_Mylast() = _Ufill(this->_Mylast(), _Newsize - _Oldsize, _Val);
            }
        else
            {
            const pointer _Newlast = this->_Myfirst() + _Newsize;
            _Fill_unchecked(this->_Myfirst(), _Newlast, _Val);
            _Destroy(_Newlast, this->_Mylast());
            this->_Mylast() = _Newlast;
            }
        }

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

template<class _Iter >

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

inline

        {   // assign [_First, _Last)
        _DEBUG_RANGE(_First, _Last);
        _Assign_range(_Unchecked(_First), _Unchecked(_Last), _Iter_cat_t<_Iter>{});
        }

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

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

inline

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

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

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

inline

        {   // subscript mutable sequence with checking
        if (size() <= _Pos)
            {
            _Xrange();
            }

        return (this->_Myfirst()[_Pos]);
        }

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

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

inline

        {   // subscript nonmutable sequence with checking
        if (size() <= _Pos)
            {
            _Xrange();
            }

        return (this->_Myfirst()[_Pos]);
        }

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

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

inline

        {   // return last element of mutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (empty())
            {   // report error
            _DEBUG_ERROR("back() called on empty vector");
            }
 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(!empty());
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (this->_Mylast()[-1]);
        }

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

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

inline

        {   // return last element of nonmutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (empty())
            {   // report error
            _DEBUG_ERROR("back() called on empty vector");
            }
 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(!empty());
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (this->_Mylast()[-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(), _STD addressof(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(), _STD addressof(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_maybe_null(this->_Myfirst()));
        }

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

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

inline

        {   // return address of first element
        return (_Unfancy_maybe_null(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 perfectly forwarding _Val at _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Where._Getcont() != _STD addressof(this->_Get_data())
            || _Where._Ptr < this->_Myfirst()
            || this->_Mylast() < _Where._Ptr)
            {
            _DEBUG_ERROR("vector emplace iterator outside range");
            }
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        const size_type _Whereoff = _Where._Ptr - this->_Myfirst();
        const bool _At_back = _Where._Ptr == this->_Mylast();

        if (!_Has_unused_capacity())
            {   // reallocate
            const size_type _Oldsize = size();

            if (_Oldsize == max_size())
                {
                _Xlength();
                }

            const size_type _Newsize = _Oldsize + 1;
            const size_type _Newcapacity = _Calculate_growth(_Newsize);

            const pointer _Newvec = this->_Getal().allocate(_Newcapacity);
            const pointer _Constructed_last = _Newvec + _Whereoff + 1;
            pointer _Constructed_first = _Constructed_last;

            _TRY_BEGIN
            this->_Getal().construct(_Unfancy(_Newvec + _Whereoff), _STD forward<_Valty>(_Val)...);
            _Constructed_first = _Newvec + _Whereoff;

            if (_At_back)
                {   // provide strong guarantee
                _Umove_if_noexcept(this->_Myfirst(), this->_Mylast(), _Newvec);
                }
            else
                {   // provide basic guarantee
                _Umove(this->_Myfirst(), _Where._Ptr, _Newvec);
                _Constructed_first = _Newvec;
                _Umove(_Where._Ptr, this->_Mylast(), _Newvec + _Whereoff + 1);
                }
            _CATCH_ALL
            _Destroy(_Constructed_first, _Constructed_last);
            this->_Getal().deallocate(_Newvec, _Newcapacity);
            _RERAISE;
            _CATCH_END

            _Change_array(_Newvec, _Newsize, _Newcapacity);
            }
        else if (_At_back)
            {   // provide strong guarantee
            _Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...);
            }
        else
            {
            _Ty _Obj(_STD forward<_Valty>(_Val)...);    // handle aliasing
            // after constructing _Obj, provide basic guarantee
            const pointer _Oldlast = this->_Mylast();
            _Orphan_range(_Where._Ptr, _Oldlast);
            this->_Getal().construct(_Unfancy(_Oldlast), _STD move(_Oldlast[-1]));
            ++this->_Mylast();
            _Move_backward_unchecked(_Where._Ptr, _Oldlast - 1, _Oldlast);
            *_Where._Ptr = _STD move(_Obj);
            }

        return (begin() + _Whereoff);
        }

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

template<class... _Valty>

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

inline

        {   // insert by perfectly forwarding into element at end, provide strong guarantee
        if (_Has_unused_capacity())
            {
            _Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...);
            }
        else
            {   // reallocate
            const size_type _Oldsize = size();

            if (_Oldsize == max_size())
                {
                _Xlength();
                }

            const size_type _Newsize = _Oldsize + 1;
            const size_type _Newcapacity = _Calculate_growth(_Newsize);
            bool _Emplaced = false;
            const pointer _Newvec = this->_Getal().allocate(_Newcapacity);

            _TRY_BEGIN
            this->_Getal().construct(_Unfancy(_Newvec + _Oldsize), _STD forward<_Valty>(_Val)...);
            _Emplaced = true;
            _Umove_if_noexcept(this->_Myfirst(), this->_Mylast(), _Newvec);
            _CATCH_ALL
            if (_Emplaced)
                {
                this->_Getal().destroy(_Unfancy(_Newvec + _Oldsize));
                }

            this->_Getal().deallocate(_Newvec, _Newcapacity);
            _RERAISE;
            _CATCH_END

            _Change_array(_Newvec, _Newsize, _Newcapacity);
            }
        }

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(), _STD addressof(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(), _STD addressof(this->_Get_data())));
        }

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

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

inline

        {   // erase element at _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Where._Getcont() != _STD addressof(this->_Get_data())
            || _Where._Ptr < this->_Myfirst()
            || this->_Mylast() <= _Where._Ptr)
            {
            _DEBUG_ERROR("vector erase iterator outside range");
            }

        _Orphan_range(_Where._Ptr, this->_Mylast());
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        _Move_unchecked(_Where._Ptr + 1, this->_Mylast(), _Where._Ptr);
        this->_Getal().destroy(_Unfancy(this->_Mylast() - 1));
        --this->_Mylast();
        return (iterator(_Where._Ptr, _STD addressof(this->_Get_data())));
        }

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

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

inline

        {   // erase [_First, _Last)
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_First._Getcont() != _STD addressof(this->_Get_data())
            || _Last._Getcont() != _STD addressof(this->_Get_data())
            || _First._Ptr < this->_Myfirst()
            || _Last._Ptr < _First._Ptr
            || this->_Mylast() < _Last._Ptr)
            {
            _DEBUG_ERROR("vector erase iterator outside range");
            }
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (_First._Ptr != _Last._Ptr)
            {   // something to do, invalidate iterators
            _Orphan_range(_First._Ptr, this->_Mylast());
            const pointer _Newlast = _Move_unchecked(_Last._Ptr, this->_Mylast(), _First._Ptr);
            _Destroy(_Newlast, this->_Mylast());
            this->_Mylast() = _Newlast;
            }

        return (iterator(_First._Ptr, _STD addressof(this->_Get_data())));
        }

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

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

inline

        {   // return first element of mutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (empty())
            {   // report error
            _DEBUG_ERROR("front() called on empty vector");
            }
 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(!empty());
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (*this->_Myfirst());
        }

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

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

inline

        {   // return first element of nonmutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (empty())
            {   // report error
            _DEBUG_ERROR("front() called on empty vector");
            }
 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(!empty());
 #endif /* _ITERATOR_DEBUG_LEVEL */

        return (*this->_Myfirst());
        }

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, const _Ty &  _Val  )

inline

        {   // insert _Val at _Where
        return (emplace(_Where, _Val));
        }

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, _CRT_GUARDOVERFLOW const size_type  _Count, const _Ty &  _Val  )

inline

        {   // insert _Count * _Val at _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Where._Getcont() != _STD addressof(this->_Get_data())
            || _Where._Ptr < this->_Myfirst()
            || this->_Mylast() < _Where._Ptr)
            {
            _DEBUG_ERROR("vector insert iterator outside range");
            }
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        const size_type _Whereoff = _Where._Ptr - this->_Myfirst();
        const bool _One_at_back = _Count == 1 && _Where._Ptr == this->_Mylast();

        if (_Count == 0)
            {   // nothing to do, avoid invalidating iterators
            }
        else if (_Count > _Unused_capacity())
            {   // reallocate
            const size_type _Oldsize = size();

            if (_Count > max_size() - _Oldsize)
                {
                _Xlength();
                }

            const size_type _Newsize = _Oldsize + _Count;
            const size_type _Newcapacity = _Calculate_growth(_Newsize);

            const pointer _Newvec = this->_Getal().allocate(_Newcapacity);
            const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
            pointer _Constructed_first = _Constructed_last;

            _TRY_BEGIN
            _Ufill(_Newvec + _Whereoff, _Count, _Val);
            _Constructed_first = _Newvec + _Whereoff;

            if (_One_at_back)
                {   // provide strong guarantee
                _Umove_if_noexcept(this->_Myfirst(), this->_Mylast(), _Newvec);
                }
            else
                {   // provide basic guarantee
                _Umove(this->_Myfirst(), _Where._Ptr, _Newvec);
                _Constructed_first = _Newvec;
                _Umove(_Where._Ptr, this->_Mylast(), _Newvec + _Whereoff + _Count);
                }
            _CATCH_ALL
            _Destroy(_Constructed_first, _Constructed_last);
            this->_Getal().deallocate(_Newvec, _Newcapacity);
            _RERAISE;
            _CATCH_END

            _Change_array(_Newvec, _Newsize, _Newcapacity);
            }
        else if (_One_at_back)
            {   // provide strong guarantee
            _Emplace_back_with_unused_capacity(_Val);
            }
        else
            {   // provide basic guarantee
            const _Ty _Tmp = _Val;  // handle aliasing
            const pointer _Oldlast = this->_Mylast();
            const size_type _Affected_elements = _Oldlast - _Where._Ptr;
            _Orphan_range(_Where._Ptr, _Oldlast);

            if (_Count > _Affected_elements)
                {   // new stuff spills off end
                this->_Mylast() = _Ufill(_Oldlast, _Count - _Affected_elements, _Tmp);
                this->_Mylast() = _Umove(_Where._Ptr, _Oldlast, this->_Mylast());
                _Fill_unchecked(_Where._Ptr, _Oldlast, _Tmp);
                }
            else
                {   // new stuff can all be assigned
                this->_Mylast() = _Umove(_Oldlast - _Count, _Oldlast, _Oldlast);
                _Move_backward_unchecked(_Where._Ptr, _Oldlast - _Count, _Oldlast);
                _Fill_unchecked(_Where._Ptr, _Where._Ptr + _Count, _Tmp);
                }
            }

        return (begin() + _Whereoff);
        }

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

template<class _Iter >

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

inline

        {   // insert [_First, _Last) at _Where
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Where._Getcont() != _STD addressof(this->_Get_data())
            || _Where._Ptr < this->_Myfirst()
            || this->_Mylast() < _Where._Ptr)
            {
            _DEBUG_ERROR("vector insert iterator outside range");
            }
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        _DEBUG_RANGE(_First, _Last);

        const size_type _Whereoff = _Where._Ptr - this->_Myfirst();
        _Insert_range(_Where, _Unchecked(_First), _Unchecked(_Last), _Iter_cat_t<_Iter>{});
        return (begin() + _Whereoff);
        }

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

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

inline

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

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>>

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

inline

        {   // assign by moving _Right
        if (this != _STD addressof(_Right))
            {   // different, assign it
            _Tidy();
            this->_Move_alloc(_Right._Getal());
            _Move_from(_STD move(_Right), _Disjunction_t<
                typename _Alty::propagate_on_container_move_assignment,
                typename _Alty::is_always_equal>{});
            }
        return (*this);
        }

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

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

inline

        {   // assign _Right
        if (this != _STD addressof(_Right))
            {   // different, assign it
#pragma warning(push)
#pragma warning(disable: 4127)  // conditional expression is constant
            if (_Alty::propagate_on_container_copy_assignment::value && this->_Getal() != _Right._Getal())
                {   // reload array
                _Tidy();
                }
#pragma warning(pop)

            this->_Copy_alloc(_Right._Getal());

            assign(_Right._Myfirst(), _Right._Mylast());
            }

        return (*this);
        }

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

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

inline

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

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

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

inline

        {   // subscript mutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (size() <= _Pos)
            {   // report error
            _DEBUG_ERROR("vector subscript 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>>

const _Ty& vector< _Ty, _Alloc >::operator[] ( const 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");
            }
 #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
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (empty())
            {
            _DEBUG_ERROR("vector empty before pop");
            }

        _Orphan_range(this->_Mylast() - 1, this->_Mylast());
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        this->_Getal().destroy(_Unfancy(this->_Mylast() - 1));
        --this->_Mylast();
        }

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

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

inline

        {   // insert element at end, provide strong guarantee
        emplace_back(_Val);
        }

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

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

inline

        {   // insert by moving into element at end, provide strong guarantee
        emplace_back(_STD move(_Val));
        }

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 ( _CRT_GUARDOVERFLOW const size_type  _Newcapacity )

inline

        {   // increase capacity to _Newcapacity (without geometric growth), provide strong guarantee
        if (_Newcapacity > capacity())
            {   // something to do (reserve() never shrinks)
            if (_Newcapacity > max_size())
                {
                _Xlength();
                }

            _Reallocate_exactly(_Newcapacity);
            }
        }

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

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

inline

        {   // trim or append value-initialized elements, provide strong guarantee
        auto _Lambda_default = [this](pointer _Dest, const size_type _Count)
            {
            return (_Udefault(_Dest, _Count));
            };

        _Resize(_Newsize, _Lambda_default);
        }

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

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

inline

        {   // trim or append copies of _Val, provide strong guarantee
        auto _Lambda_fill = [this, &_Val](pointer _Dest, const size_type _Count)
            {
            return (_Ufill(_Dest, _Count, _Val));
            };

        _Resize(_Newsize, _Lambda_fill);
        }

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

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

inline

        {   // reduce capacity to size, provide strong guarantee
        if (_Has_unused_capacity())
            {   // something to do
            if (empty())
                {
                _Tidy();
                }
            else
                {
                _Reallocate_exactly(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 ( vector< _Ty, _Alloc > &  _Right )

inline

        {   // exchange contents with _Right
        if (this != _STD addressof(_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:

• VS2017/inc/vector