basic_string< _Elem, _Traits, _Alloc > Class Template Reference

Inheritance diagram for basic_string< _Elem, _Traits, _Alloc >:

Public Types
typedef basic_string< _Elem, _Traits, _Alloc >	_Myt
typedef _String_alloc< _String_base_types< _Elem, _Alloc > >	_Mybase
typedef _Traits	traits_type
typedef _Alloc	allocator_type
typedef _Mybase::_Alty	_Alty
typedef _Mybase::_Mydata_t	_Mydata_t
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
using	_Use_memcpy_move = bool_constant< _Is_specialization< _Traits, char_traits >::value &&is_trivial< pointer >::value >
template<class _Iter >
using	_Is_elem_cptr = _Disjunction_t< is_same< _Iter, const _Elem *const >, is_same< _Iter, _Elem *const >, is_same< _Iter, const _Elem * >, is_same< _Iter, _Elem * >>
Public Types inherited from _String_alloc< _String_base_types< _Elem, _Alloc > >
enum
enum
typedef _String_alloc< _String_base_types< _Elem, _Alloc > >	_Myt
typedef _String_base_types< _Elem, _Alloc >::_Alloc	_Alloc
typedef _String_base_types< _Elem, _Alloc >::_Alty	_Alty
typedef _String_base_types< _Elem, _Alloc >::_Val_types	_Val_types
typedef _String_val< _Val_types >	_Mydata_t
typedef _Mydata_t::_Bxty	_Bxty
typedef _Val_types::value_type	value_type
typedef _Val_types::size_type	size_type
typedef _Val_types::difference_type	difference_type
typedef _Val_types::pointer	pointer
typedef _Val_types::const_pointer	const_pointer
typedef _Val_types::reference	reference
typedef _Val_types::const_reference	const_reference
typedef _String_iterator< _Mydata_t >	iterator
typedef _String_const_iterator< _Mydata_t >	const_iterator

Public Member Functions
	basic_string (const _Myt &_Right)
	basic_string (const _Myt &_Right, const _Alloc &_Al)
	basic_string () _NOEXCEPT_OP(is_nothrow_default_constructible< _Alloc >
	basic_string (const _Alloc &_Al) _NOEXCEPT
	basic_string (const _Myt &_Right, const size_type _Roff, const _Alloc &_Al=_Alloc())
	basic_string (const _Myt &_Right, const size_type _Roff, const size_type _Count, const _Alloc &_Al=_Alloc())
	basic_string (_In_reads_(_Count) const _Elem *const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count)
	basic_string (_In_reads_(_Count) const _Elem *const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count, const _Alloc &_Al)
	basic_string (_In_z_ const _Elem *const _Ptr)
	basic_string (_In_z_ const _Elem *const _Ptr, const _Alloc &_Al)
	basic_string (_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)
	basic_string (_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch, const _Alloc &_Al)
template<class _Iter , class = enable_if_t<_Is_iterator<_Iter>::value>>
	basic_string (_Iter _First, _Iter _Last, const _Alloc &_Al=_Alloc())
template<class _Iter >
void	_Construct (_Iter _First, const _Iter _Last, input_iterator_tag)
template<class _Iter >
void	_Construct (const _Iter _First, const _Iter _Last, forward_iterator_tag)
void	_Construct (_Elem *const _First, _Elem *const _Last, random_access_iterator_tag)
void	_Construct (const _Elem *const _First, const _Elem *const _Last, random_access_iterator_tag)
	basic_string (_Myt &&_Right) _NOEXCEPT
	basic_string (_Myt &&_Right, const _Alloc &_Al)
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT_OP(_Alty
_Myt &	assign (_Myt &&_Right) _NOEXCEPT_OP(_Alty
void	_Assign_rv_contents (_Myt &&_Right, true_type)
void	_Assign_rv_contents (_Myt &&_Right, false_type)
void	_Assign_rv_contents_with_alloc_always_equal (_Myt &&_Right, true_type)
void	_Assign_rv_contents_with_alloc_always_equal (_Myt &&_Right, false_type)
void	_Assign_lv_contents (const _Myt &_Right)
	basic_string (initializer_list< _Elem > _Ilist, const _Alloc &_Al=allocator_type())
_Myt &	operator= (initializer_list< _Elem > _Ilist)
_Myt &	operator+= (initializer_list< _Elem > _Ilist)
_Myt &	assign (initializer_list< _Elem > _Ilist)
_Myt &	append (initializer_list< _Elem > _Ilist)
iterator	insert (const const_iterator _Where, const initializer_list< _Elem > _Ilist)
_Myt &	replace (const const_iterator _First, const const_iterator _Last, const initializer_list< _Elem > _Ilist)
	~basic_string () _NOEXCEPT
_Myt &	operator= (const _Myt &_Right)
_Myt &	operator= (_In_z_ const _Elem *const _Ptr)
_Myt &	operator= (const _Elem _Ch)
_Myt &	operator+= (const _Myt &_Right)
_Myt &	operator+= (_In_z_ const _Elem *const _Ptr)
_Myt &	operator+= (_Elem _Ch)
_Myt &	append (const _Myt &_Right)
_Myt &	append (const _Myt &_Right, const size_type _Roff, size_type _Count=npos)
_Myt &	append (_In_reads_(_Count) const _Elem *const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count)
_Myt &	append (_In_z_ const _Elem *const _Ptr)
_Myt &	append (_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)
template<class _Iter , class = enable_if_t<_Is_iterator<_Iter>::value>>
_Myt &	append (const _Iter _First, const _Iter _Last)
_Myt &	assign (const _Myt &_Right)
_Myt &	assign (const _Myt &_Right, const size_type _Roff, size_type _Count=npos)
_Myt &	assign (_In_reads_(_Count) const _Elem *const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count)
_Myt &	assign (_In_z_ const _Elem *const _Ptr)
_Myt &	assign (_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)
template<class _Iter , class = enable_if_t<_Is_iterator<_Iter>::value>>
_Myt &	assign (const _Iter _First, const _Iter _Last)
_Myt &	insert (const size_type _Off, const _Myt &_Right)
_Myt &	insert (const size_type _Off, const _Myt &_Right, const size_type _Roff, size_type _Count=npos)
_Myt &	insert (const size_type _Off, _In_reads_(_Count) const _Elem *const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count)
_Myt &	insert (const size_type _Off, _In_z_ const _Elem *const _Ptr)
_Myt &	insert (const size_type _Off, _CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)
iterator	insert (const const_iterator _Where, const _Elem _Ch)
iterator	insert (const const_iterator _Where, _CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)
template<class _Iter , class = enable_if_t<_Is_iterator<_Iter>::value>>
iterator	insert (const const_iterator _Where, const _Iter _First, const _Iter _Last)
_Myt &	erase (const size_type _Off=0)
_Myt &	erase (const size_type _Off, const size_type _Count)
iterator	erase (const const_iterator _Where)
iterator	erase (const const_iterator _First, const const_iterator _Last)
void	clear () _NOEXCEPT
_Myt &	replace (const size_type _Off, const size_type _N0, const _Myt &_Right)
_Myt &	replace (const size_type _Off, size_type _N0, const _Myt &_Right, const size_type _Roff, size_type _Count=npos)
_Myt &	replace (const size_type _Off, size_type _N0, _In_reads_(_Count) const _Elem *const _Ptr, const size_type _Count)
_Myt &	replace (const size_type _Off, const size_type _N0, _In_z_ const _Elem *const _Ptr)
_Myt &	replace (const size_type _Off, size_type _N0, const size_type _Count, const _Elem _Ch)
_Myt &	replace (const const_iterator _First, const const_iterator _Last, const _Myt &_Right)
_Myt &	replace (const const_iterator _First, const const_iterator _Last, _In_reads_(_Count) const _Elem *const _Ptr, const size_type _Count)
_Myt &	replace (const const_iterator _First, const const_iterator _Last, _In_z_ const _Elem *const _Ptr)
_Myt &	replace (const const_iterator _First, const const_iterator _Last, const size_type _Count, const _Elem _Ch)
template<class _Iter >
_Myt &	_Replace_range (const const_iterator _First, const const_iterator _Last, const _Iter _First2, const _Iter _Last2, false_type)
template<class _Ptr >
_Myt &	_Replace_range (const const_iterator _First, const const_iterator _Last, const _Ptr _First2, const _Ptr _Last2, true_type)
template<class _Iter , class = enable_if_t<_Is_iterator<_Iter>::value>>
_Myt &	replace (const const_iterator _First, const const_iterator _Last, const _Iter _First2, const _Iter _Last2)
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
void	shrink_to_fit ()
reference	at (const size_type _Off)
const_reference	at (const size_type _Off) const
reference	operator[] (const size_type _Off)
const_reference	operator[] (const size_type _Off) const
void	push_back (const _Elem _Ch)
void	pop_back ()
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
_Ret_z_ const _Elem *	c_str () const _NOEXCEPT
_Ret_z_ const _Elem *	data () const _NOEXCEPT
size_type	length () const _NOEXCEPT
size_type	size () const _NOEXCEPT
size_type	max_size () const _NOEXCEPT
void	resize (_CRT_GUARDOVERFLOW const size_type _Newsize)
void	resize (_CRT_GUARDOVERFLOW const size_type _Newsize, const _Elem _Ch)
size_type	capacity () const _NOEXCEPT
void	reserve (_CRT_GUARDOVERFLOW const size_type _Newcap=0)
bool	empty () const _NOEXCEPT
size_type	copy (_Out_writes_(_Count) _Elem *const _Ptr, size_type _Count, const size_type _Off=0) const
	_Pre_satisfies_ (_Dest_size >=_Count) size_type _Copy_s(_Out_writes_all_(_Dest_size) _Elem *const _Dest
Public Member Functions inherited from _String_alloc< _String_base_types< _Elem, _Alloc > >
value_type *	_Myptr ()
const value_type *	_Myptr () const
	_String_alloc ()
	_String_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
_Mydata_t &	_Get_data () _NOEXCEPT
const _Mydata_t &	_Get_data () const _NOEXCEPT
size_type &	_Mysize () _NOEXCEPT
const size_type &	_Mysize () const _NOEXCEPT
size_type &	_Myres () _NOEXCEPT
const size_type &	_Myres () const _NOEXCEPT

Public Attributes
const size_type	_Dest_size
const size_type size_type	_Count

Static Public Attributes
static constexpr size_t	_Memcpy_move_offset = offsetof(_Mydata_t, _Bx)
static constexpr size_t	_Memcpy_move_size = sizeof(_Mydata_t) - _Memcpy_move_offset
static _PGLOBAL const size_type	npos

Member Typedef Documentation

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::_Alty basic_string< _Elem, _Traits, _Alloc >::_Alty

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

template<class _Iter >

using basic_string< _Elem, _Traits, _Alloc >::_Is_elem_cptr = _Disjunction_t< is_same<_Iter, const _Elem * const>, is_same<_Iter, _Elem * const>, is_same<_Iter, const _Elem *>, is_same<_Iter, _Elem *>>

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _String_alloc<_String_base_types<_Elem, _Alloc> > basic_string< _Elem, _Traits, _Alloc >::_Mybase

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::_Mydata_t basic_string< _Elem, _Traits, _Alloc >::_Mydata_t

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef basic_string<_Elem, _Traits, _Alloc> basic_string< _Elem, _Traits, _Alloc >::_Myt

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

using basic_string< _Elem, _Traits, _Alloc >::_Use_memcpy_move = bool_constant< _Is_specialization<_Traits, char_traits>::value && is_trivial<pointer>::value>

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Alloc basic_string< _Elem, _Traits, _Alloc >::allocator_type

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::const_iterator basic_string< _Elem, _Traits, _Alloc >::const_iterator

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::const_pointer basic_string< _Elem, _Traits, _Alloc >::const_pointer

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::const_reference basic_string< _Elem, _Traits, _Alloc >::const_reference

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _STD reverse_iterator<const_iterator> basic_string< _Elem, _Traits, _Alloc >::const_reverse_iterator

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::difference_type basic_string< _Elem, _Traits, _Alloc >::difference_type

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::iterator basic_string< _Elem, _Traits, _Alloc >::iterator

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::pointer basic_string< _Elem, _Traits, _Alloc >::pointer

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::reference basic_string< _Elem, _Traits, _Alloc >::reference

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _STD reverse_iterator<iterator> basic_string< _Elem, _Traits, _Alloc >::reverse_iterator

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::size_type basic_string< _Elem, _Traits, _Alloc >::size_type

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Traits basic_string< _Elem, _Traits, _Alloc >::traits_type

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

typedef _Mybase::value_type basic_string< _Elem, _Traits, _Alloc >::value_type

Constructor & Destructor Documentation

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( const _Myt &  _Right )

inline

        : _Mybase(_Right._Getal().select_on_container_copy_construction())
        {   // construct by copying _Right
        _Tidy_init();
        _Assign_lv_contents(_Right);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( const _Myt &  _Right, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct by copying with allocator
        _Tidy_init();
        _Assign_lv_contents(_Right);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( )

inline

        : _Mybase()
        {   // construct empty string
        _Tidy_init();
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( const _Alloc &  _Al )

inlineexplicit

        : _Mybase(_Al)
        {   // construct empty string with allocator
        _Tidy_init();
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( const _Myt &  _Right, const size_type  _Roff, const _Alloc &  _Al = _Alloc()  )

inline

        : _Mybase(_Al)
        {   // construct from _Right [_Roff, <end>)
        _Tidy_init();
        assign(_Right, _Roff, npos);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( const _Myt &  _Right, const size_type  _Roff, const size_type  _Count, const _Alloc &  _Al = _Alloc()  )

inline

        : _Mybase(_Al)
        {   // construct from _Right [_Roff, _Roff + _Count)
        _Tidy_init();
        assign(_Right, _Roff, _Count);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _In_reads_(_Count) const _Elem *const  _Ptr, _CRT_GUARDOVERFLOW const size_type  _Count  )

inline

        : _Mybase()
        {   // construct from [_Ptr, _Ptr + _Count)
        _Tidy_init();
        assign(_Ptr, _Count);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _In_reads_(_Count) const _Elem *const  _Ptr, _CRT_GUARDOVERFLOW const size_type  _Count, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct from [_Ptr, _Ptr + _Count) with allocator
        _Tidy_init();
        assign(_Ptr, _Count);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _In_z_ const _Elem *const  _Ptr )

inline

        : _Mybase()
        {   // construct from [_Ptr, <null>)
        _Tidy_init();
        assign(_Ptr);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _In_z_ const _Elem *const  _Ptr, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct from [_Ptr, <null>) with allocator
        _Tidy_init();
        assign(_Ptr);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _CRT_GUARDOVERFLOW const size_type  _Count, const _Elem  _Ch  )

inline

        : _Mybase()
        {   // construct from _Count * _Ch
        _Tidy_init();
        assign(_Count, _Ch);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _CRT_GUARDOVERFLOW const size_type  _Count, const _Elem  _Ch, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct from _Count * _Ch with allocator
        _Tidy_init();
        assign(_Count, _Ch);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

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

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _Iter  _First, _Iter  _Last, const _Alloc &  _Al = _Alloc()  )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _Myt &&  _Right )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _Myt &&  _Right, const _Alloc &  _Al  )

inline

        : _Mybase(_Al)
        {   // construct by moving _Right, allocator
        _Assign_rv_contents(_STD move(_Right), typename _Alty::is_always_equal{});
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( initializer_list< _Elem >  _Ilist, const _Alloc &  _Al = allocator_type()  )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::~basic_string ( )

inline

        {   // destroy the string
        _Tidy_deallocate();
        }

Member Function Documentation

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::_Assign_lv_contents ( const _Myt &  _Right )

inline

        {   // assign by copying the data stored in _Right
            // pre: *this is in a valid but unspecified state
        assign(_Right, 0, npos);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::_Assign_rv_contents ( _Myt &&  _Right, true_type    )

inline

        {   // assign either as an rvalue or as an lvalue copy, allocators always equal optimization
            // pre: this != &_Right
            // pre: allocator propagation (POCMA) from _Right, if necessary, is complete
            // pre: *this owns no memory, iterators orphaned (note: _Buf/_Ptr/_Mysize/_Myres may be garbage init)
        _Assign_rv_contents_with_alloc_always_equal(_STD move(_Right), _Use_memcpy_move{});
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::_Assign_rv_contents ( _Myt &&  _Right, false_type    )

inline

        {   // assign either as an rvalue or as an lvalue copy, allocators potentially unequal
            // pre: this != &_Right
            // pre: allocator propagation (POCMA) from _Right, if necessary, is complete
            // pre: *this owns no memory, iterators orphaned (note: _Buf/_Ptr/_Mysize/_Myres may be garbage init)
        if (this->_Getal() == _Right._Getal())
            {
            _Assign_rv_contents_with_alloc_always_equal(_STD move(_Right), _Use_memcpy_move{});
            }
        else
            {
            _Tidy_init();
            _Assign_lv_contents(_Right);
            }
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::_Assign_rv_contents_with_alloc_always_equal ( _Myt &&  _Right, true_type    )

inline

        {   // assign by stealing _Right's buffer, memcpy optimization
            // pre: this != &_Right
            // pre: allocator propagation (POCMA) from _Right, if necessary, is complete
            // pre: *this owns no memory, iterators orphaned (note: _Buf/_Ptr/_Mysize/_Myres may be garbage init)
        auto& _Right_data = _Right._Get_data();

#if _ITERATOR_DEBUG_LEVEL != 0
        if (_Right_data._Large_string_engaged())
            {   // take ownership of _Right's iterators along with its buffer
            this->_Swap_all(_Right);
            }
        else
            {
            _Right._Orphan_all();
            }
#endif /* _ITERATOR_DEBUG_LEVEL != 0 */

        const auto _My_data_mem = reinterpret_cast<unsigned char *>(_STD addressof(this->_Get_data()))
            + _Memcpy_move_offset;
        const auto _Right_data_mem = reinterpret_cast<unsigned char *>(_STD addressof(_Right_data))
            + _Memcpy_move_offset;
        _CSTD memcpy(_My_data_mem, _Right_data_mem, _Memcpy_move_size);
        _Right._Tidy_init();
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::_Assign_rv_contents_with_alloc_always_equal ( _Myt &&  _Right, false_type    )

inline

        {   // assign by stealing _Right's buffer, general case
            // pre: this != &_Right
            // pre: allocator propagation (POCMA) from _Right, if necessary, is complete
            // pre: *this owns no memory, iterators orphaned (note: _Buf/_Ptr/_Mysize/_Myres may be garbage init)
        auto& _My_data = this->_Get_data();
        auto& _Right_data = _Right._Get_data();
        if (_Right_data._Large_string_engaged())
            {   // steal buffer
            this->_Getal().construct(_STD addressof(_My_data._Bx._Ptr), _Right_data._Bx._Ptr);
            _Right_data._Bx._Ptr = pointer();
            this->_Swap_all(_Right);
            }
        else
            {   // copy small string buffer
            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, _Right_data._Mysize + 1);
            _Right._Orphan_all();
            }

        _My_data._Mysize = _Right_data._Mysize;
        _My_data._Myres = _Right_data._Myres;
        _Right._Tidy_init();
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

template<class _Iter >

void basic_string< _Elem, _Traits, _Alloc >::_Construct ( _Iter  _First, const _Iter  _Last, input_iterator_tag    )

inline

        {   // initialize from [_First, _Last), input iterators
        _TRY_BEGIN
        for (; _First != _Last; ++_First)
            push_back(static_cast<_Elem>(*_First));
        _CATCH_ALL
        _Tidy_deallocate();
        _RERAISE;
        _CATCH_END
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

template<class _Iter >

void basic_string< _Elem, _Traits, _Alloc >::_Construct ( const _Iter  _First, const _Iter  _Last, forward_iterator_tag    )

inline

        {   // initialize from [_First, _Last), forward iterators
        const size_type _Count = _STD distance(_First, _Last);
        reserve(_Count);
        _Construct(_First, _Last, input_iterator_tag());
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::_Construct ( _Elem *const  _First, _Elem *const  _Last, random_access_iterator_tag    )

inline

        {   // initialize from [_First, _Last), pointers
        if (_First != _Last)
            {
            assign(_First, _Last - _First);
            }
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::_Construct ( const _Elem *const  _First, const _Elem *const  _Last, random_access_iterator_tag    )

inline

        {   // initialize from [_First, _Last), const pointers
        if (_First != _Last)
            {
            assign(_First, _Last - _First);
            }
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string< _Elem, _Traits, _Alloc >::_Pre_satisfies_

(

_Dest_size >=

_Count

)

const

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

template<class _Iter >

_Myt& basic_string< _Elem, _Traits, _Alloc >::_Replace_range ( const const_iterator  _First, const const_iterator  _Last, const _Iter  _First2, const _Iter  _Last2, false_type    )

inline

        {   // replace [_First, _Last) with [_First2, _Last2), input iterators
        const _Myt _Right(_First2, _Last2, get_allocator());
        replace(_First, _Last, _Right);
        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

template<class _Ptr >

_Myt& basic_string< _Elem, _Traits, _Alloc >::_Replace_range ( const const_iterator  _First, const const_iterator  _Last, const _Ptr  _First2, const _Ptr  _Last2, true_type    )

inline

        {   // replace [_First, _Last) with [_First2, _Last2), pointers
        if (_First2 == _Last2)
            {
            erase(_First - cbegin(), _Last - _First);
            }
        else
            {
            replace(_First - cbegin(), _Last - _First, _First2, _Last2 - _First2);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::append ( initializer_list< _Elem >  _Ilist )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::append ( const _Myt &  _Right )

inline

        {   // append _Right
        return (append(_Right, 0, npos));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::append ( const _Myt &  _Right, const size_type  _Roff, size_type  _Count = npos  )

inline

        {   // append _Right [_Roff, _Roff + _Count)
        _Right._Check_offset(_Roff);
        _Count = _Right._Clamp_suffix_size(_Roff, _Count);
        if (npos - this->_Mysize() <= _Count)
            {
            _Xlen();    // result too long
            }

        const size_type _Num = this->_Mysize() + _Count;
        if (_Count != 0 && _Grow(_Num))
            {   // make room and append new stuff
            _Traits::copy(this->_Myptr() + this->_Mysize(), _Right._Myptr() + _Roff, _Count);
            _Eos(_Num);
            }
        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::append ( _In_reads_(_Count) const _Elem *const  _Ptr, _CRT_GUARDOVERFLOW const size_type  _Count  )

inline

        {   // append [_Ptr, _Ptr + _Count)
        if (_Inside(_Ptr))
            {
            return (append(*this, _Ptr - this->_Myptr(), _Count));  // substring
            }

        if (npos - this->_Mysize() <= _Count)
            {
            _Xlen();    // result too long
            }

        const size_type _Num = this->_Mysize() + _Count;
        if (_Count != 0 && _Grow(_Num))
            {   // make room and append new stuff
            _Traits::copy(this->_Myptr() + this->_Mysize(), _Ptr, _Count);
            _Eos(_Num);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::append ( _In_z_ const _Elem *const  _Ptr )

inline

        {   // append [_Ptr, <null>)
        return (append(_Ptr, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::append ( _CRT_GUARDOVERFLOW const size_type  _Count, const _Elem  _Ch  )

inline

        {   // append _Count * _Ch
        if (npos - this->_Mysize() <= _Count)
            {
            _Xlen();    // result too long
            }

        const size_type _Num = this->_Mysize() + _Count;
        if (_Count != 0 && _Grow(_Num))
            {   // make room and append new stuff using assign
            _Chassign(this->_Mysize(), _Count, _Ch);
            _Eos(_Num);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

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

_Myt& basic_string< _Elem, _Traits, _Alloc >::append ( const _Iter  _First, const _Iter  _Last  )

inline

        {   // append [_First, _Last), input iterators
        return (replace(end(), end(), _First, _Last));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        *this = _STD move(_Right);
        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( initializer_list< _Elem >  _Ilist )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( const _Myt &  _Right )

inline

        {   // assign _Right
        *this = _Right;
        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( const _Myt &  _Right, const size_type  _Roff, size_type  _Count = npos  )

inline

        {   // assign _Right [_Roff, _Roff + _Count)
        _Right._Check_offset(_Roff);
        _Count = _Right._Clamp_suffix_size(_Roff, _Count);

        if (this == _STD addressof(_Right))
            {   // substring
            erase(_Roff + _Count);
            erase(0, _Roff);
            }
        else if (_Grow(_Count))
            {   // make room and assign new stuff
            _Traits::copy(this->_Myptr(), _Right._Myptr() + _Roff, _Count);
            _Eos(_Count);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( _In_reads_(_Count) const _Elem *const  _Ptr, _CRT_GUARDOVERFLOW const size_type  _Count  )

inline

        {   // assign [_Ptr, _Ptr + _Count)
        if (_Inside(_Ptr))
            {
            return (assign(*this, _Ptr - this->_Myptr(), _Count));  // substring
            }

        if (_Grow(_Count))
            {   // make room and assign new stuff
            _Traits::copy(this->_Myptr(), _Ptr, _Count);
            _Eos(_Count);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( _In_z_ const _Elem *const  _Ptr )

inline

        {   // assign [_Ptr, <null>)
        return (assign(_Ptr, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( _CRT_GUARDOVERFLOW const size_type  _Count, const _Elem  _Ch  )

inline

        {   // assign _Count * _Ch
        if (_Count == npos)
            {
            _Xlen();    // result too long
            }

        if (_Grow(_Count))
            {   // make room and assign new stuff
            _Chassign(0, _Count, _Ch);
            _Eos(_Count);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

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

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( const _Iter  _First, const _Iter  _Last  )

inline

        {   // assign [_First, _Last), input iterators
        return (replace(begin(), end(), _First, _Last));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

reference basic_string< _Elem, _Traits, _Alloc >::at ( const size_type  _Off )

inline

        {   // subscript mutable sequence with checking
        _Check_offset_exclusive(_Off);
        return (this->_Myptr()[_Off]);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_reference basic_string< _Elem, _Traits, _Alloc >::at ( const size_type  _Off ) const

inline

        {   // subscript immutable sequence with checking
        _Check_offset_exclusive(_Off);
        return (this->_Myptr()[_Off]);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

reference basic_string< _Elem, _Traits, _Alloc >::back ( )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_reference basic_string< _Elem, _Traits, _Alloc >::back ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

iterator basic_string< _Elem, _Traits, _Alloc >::begin ( )

inline

        {   // return iterator for beginning of mutable sequence
        auto _My_data = _STD addressof(this->_Get_data());
        return (iterator(this->_Getal().address(*_My_data->_Myptr()), _My_data));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_iterator basic_string< _Elem, _Traits, _Alloc >::begin ( ) const

inline

        {   // return iterator for beginning of immutable sequence
        auto _My_data = _STD addressof(this->_Get_data());
        return (const_iterator(this->_Getal().address(*_My_data->_Myptr()), _My_data));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Ret_z_ const _Elem* basic_string< _Elem, _Traits, _Alloc >::c_str ( ) const

inline

        {   // return pointer to null-terminated immutable array
        return (this->_Myptr());
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

size_type basic_string< _Elem, _Traits, _Alloc >::capacity ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_iterator basic_string< _Elem, _Traits, _Alloc >::cbegin ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_iterator basic_string< _Elem, _Traits, _Alloc >::cend ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::clear ( )

inline

        {   // erase all
        _Eos(0);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

size_type basic_string< _Elem, _Traits, _Alloc >::copy ( _Out_writes_(_Count) _Elem *const  _Ptr, size_type  _Count, const size_type  _Off = 0  ) const

inline

        {   // copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
        _Check_offset(_Off);
        _Count = _Clamp_suffix_size(_Off, _Count);
        _Traits::copy(_Ptr, this->_Myptr() + _Off, _Count);
        return (_Count);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_reverse_iterator basic_string< _Elem, _Traits, _Alloc >::crbegin ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_reverse_iterator basic_string< _Elem, _Traits, _Alloc >::crend ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Ret_z_ const _Elem* basic_string< _Elem, _Traits, _Alloc >::data ( ) const

inline

        {   // return pointer to immutable array
        return (this->_Myptr());
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

bool basic_string< _Elem, _Traits, _Alloc >::empty ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

iterator basic_string< _Elem, _Traits, _Alloc >::end ( )

inline

        {   // return iterator for end of mutable sequence
        auto _My_data = _STD addressof(this->_Get_data());
        return (iterator(this->_Getal().address(*_My_data->_Myptr()) + _My_data->_Mysize, _My_data));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_iterator basic_string< _Elem, _Traits, _Alloc >::end ( ) const

inline

        {   // return iterator for end of immutable sequence
        auto _My_data = _STD addressof(this->_Get_data());
        return (const_iterator(this->_Getal().address(*_My_data->_Myptr()) + _My_data->_Mysize, _My_data));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::erase ( const size_type  _Off = 0 )

inline

        {   // erase elements [_Off, ...)
        _Check_offset(_Off);
        _Eos(_Off);
        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::erase ( const size_type  _Off, const size_type  _Count  )

inline

        {   // erase elements [_Off, _Off + _Count)
        _Check_offset(_Off);
        if (this->_Mysize() - _Off <= _Count)
            {
            _Eos(_Off); // erase elements [_Off, ...)
            }
        else if (_Count != 0)
            {   // move elements down
            value_type *_Ptr = this->_Myptr() + _Off;
            size_type _Newsize = this->_Mysize() - _Count;
            _Traits::move(_Ptr, _Ptr + _Count, _Newsize - _Off);
            _Eos(_Newsize);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

iterator basic_string< _Elem, _Traits, _Alloc >::erase ( const const_iterator  _Where )

inline

        {   // erase element at _Where
        const size_type _Count = _Where - begin();
        erase(_Count, 1);
        return (begin() + _Count);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

iterator basic_string< _Elem, _Traits, _Alloc >::erase ( const const_iterator  _First, const const_iterator  _Last  )

inline

        {   // erase substring [_First, _Last)
        _DEBUG_RANGE(_First, _Last);
        const size_type _Count = _First - begin();
        erase(_Count, _Last - _First);
        return (begin() + _Count);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

reference basic_string< _Elem, _Traits, _Alloc >::front ( )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_reference basic_string< _Elem, _Traits, _Alloc >::front ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

iterator basic_string< _Elem, _Traits, _Alloc >::insert ( const const_iterator  _Where, const initializer_list< _Elem >  _Ilist  )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::insert ( const size_type  _Off, const _Myt &  _Right  )

inline

        {   // insert _Right at _Off
        return (insert(_Off, _Right, 0, npos));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::insert ( const size_type  _Off, const _Myt &  _Right, const size_type  _Roff, size_type  _Count = npos  )

inline

        {   // insert _Right [_Roff, _Roff + _Count) at _Off
        _Check_offset(_Off);
        _Right._Check_offset(_Roff);
        _Count = _Right._Clamp_suffix_size(_Roff, _Count);
        if (npos - this->_Mysize() <= _Count)
            {
            _Xlen();    // result too long
            }

        const size_type _Num = this->_Mysize() + _Count;
        if (_Count != 0 && _Grow(_Num))
            {   // make room and insert new stuff
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off,
                this->_Mysize() - _Off);    // empty out hole
            if (this == _STD addressof(_Right))
                {
                _Traits::move(this->_Myptr() + _Off, this->_Myptr() + _Min_value(_Off, _Roff), _Count); // substring
                }
            else
                {
                _Traits::copy(this->_Myptr() + _Off, _Right._Myptr() + _Roff, _Count);  // fill hole
                }

            _Eos(_Num);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::insert ( const size_type  _Off, _In_reads_(_Count) const _Elem *const  _Ptr, _CRT_GUARDOVERFLOW const size_type  _Count  )

inline

        {   // insert [_Ptr, _Ptr + _Count) at _Off
        if (_Inside(_Ptr))
            {
            return (insert(_Off, *this,
                _Ptr - this->_Myptr(), _Count));    // substring
            }

        _Check_offset(_Off);
        if (npos - this->_Mysize() <= _Count)
            {
            _Xlen();    // result too long
            }

        const size_type _Num = this->_Mysize() + _Count;
        if (_Count != 0 && _Grow(_Num))
            {   // make room and insert new stuff
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off,
                this->_Mysize() - _Off);    // empty out hole
            _Traits::copy(this->_Myptr() + _Off, _Ptr, _Count); // fill hole
            _Eos(_Num);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::insert ( const size_type  _Off, _In_z_ const _Elem *const  _Ptr  )

inline

        {   // insert [_Ptr, <null>) at _Off
        return (insert(_Off, _Ptr, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::insert ( const size_type  _Off, _CRT_GUARDOVERFLOW const size_type  _Count, const _Elem  _Ch  )

inline

        {   // insert _Count * _Ch at _Off
        _Check_offset(_Off);
        if (npos - this->_Mysize() <= _Count)
            {
            _Xlen();    // result too long
            }

        const size_type _Num = this->_Mysize() + _Count;
        if (_Count != 0 && _Grow(_Num))
            {   // make room and insert new stuff
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off,
                this->_Mysize() - _Off);    // empty out hole
            _Chassign(_Off, _Count, _Ch);   // fill hole
            _Eos(_Num);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

iterator basic_string< _Elem, _Traits, _Alloc >::insert ( const const_iterator  _Where, const _Elem  _Ch  )

inline

        {   // insert _Ch at _Where
        size_type _Off = _Where - begin();
        insert(_Off, 1, _Ch);
        return (begin() + _Off);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

iterator basic_string< _Elem, _Traits, _Alloc >::insert ( const const_iterator  _Where, _CRT_GUARDOVERFLOW const size_type  _Count, const _Elem  _Ch  )

inline

        {   // insert _Count * _Elem at _Where
        const size_type _Off = _Where - begin();
        insert(_Off, _Count, _Ch);
        return (begin() + _Off);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

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

iterator basic_string< _Elem, _Traits, _Alloc >::insert ( const const_iterator  _Where, const _Iter  _First, const _Iter  _Last  )

inline

        {   // insert [_First, _Last) at _Where, input iterators
        const size_type _Off = _Where - begin();
        replace(_Where, _Where, _First, _Last);
        return (begin() + _Off);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

size_type basic_string< _Elem, _Traits, _Alloc >::length ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

size_type basic_string< _Elem, _Traits, _Alloc >::max_size ( ) const

inline

        {   // return maximum possible length of sequence
        const size_type _Num = this->_Getal().max_size();
        return (_Num <= 1 ? 1 : _Num - 1);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator+= ( initializer_list< _Elem >  _Ilist )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator+= ( const _Myt &  _Right )

inline

        {   // append _Right
        return (append(_Right));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator+= ( _In_z_ const _Elem *const  _Ptr )

inline

        {   // append [_Ptr, <null>)
        return (append(_Ptr));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator+= ( _Elem  _Ch )

inline

        {   // append 1 * _Ch
        push_back(_Ch);
        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != _STD addressof(_Right))
            {   // different, assign it
            _Tidy_deallocate();
            this->_Move_alloc(_Right._Getal());
            // tag dispatch to remove unnecessary exception handling codegen in the
            // equal allocators case
            _Assign_rv_contents(_STD move(_Right),
                bool_constant<_Alty::propagate_on_container_move_assignment::value
                || _Alty::is_always_equal::value>{});
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator= ( initializer_list< _Elem >  _Ilist )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator= ( const _Myt &  _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())
                {   // change allocator before copying
                _Tidy_deallocate();
                }
#pragma warning(pop)

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

            _Assign_lv_contents(_Right);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator= ( _In_z_ const _Elem *const  _Ptr )

inline

        {   // assign [_Ptr, <null>)
        return (assign(_Ptr));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::operator= ( const _Elem  _Ch )

inline

        {   // assign 1 * _Ch
        return (assign(1, _Ch));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

reference basic_string< _Elem, _Traits, _Alloc >::operator[] ( const size_type  _Off )

inline

        {   // subscript mutable sequence
        _IDL_VERIFY(_Off <= this->_Mysize(), "string subscript out of range");
        return (this->_Myptr()[_Off]);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_reference basic_string< _Elem, _Traits, _Alloc >::operator[] ( const size_type  _Off ) const

inline

        {   // subscript immutable sequence
        _IDL_VERIFY(_Off <= this->_Mysize(), "string subscript out of range");
        return (this->_Myptr()[_Off]);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::pop_back ( )

inline

        {   // erase element at end
        erase(this->_Mysize() - 1); // throws if _Mysize() == 0
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::push_back ( const _Elem  _Ch )

inline

        {   // insert element at end
        auto& _My_data = this->_Get_data();
        auto& _Sz = _My_data._Mysize;
        if (_Sz == _My_data._Myres)
            {
            _Grow(_Sz + 1); // _Grow checks for overflow
            }

        auto _Ptr = _My_data._Myptr();
        _Traits::assign(_Ptr[_Sz], _Ch);
        ++_Sz;
        _Traits::assign(_Ptr[_Sz], _Elem());
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

reverse_iterator basic_string< _Elem, _Traits, _Alloc >::rbegin ( )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_reverse_iterator basic_string< _Elem, _Traits, _Alloc >::rbegin ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

reverse_iterator basic_string< _Elem, _Traits, _Alloc >::rend ( )

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const_reverse_iterator basic_string< _Elem, _Traits, _Alloc >::rend ( ) const

inline

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

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const const_iterator  _First, const const_iterator  _Last, const initializer_list< _Elem >  _Ilist  )

inline

        {   // replace with initializer_list
        return (replace(_First, _Last, _Ilist.begin(), _Ilist.end()));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const size_type  _Off, const size_type  _N0, const _Myt &  _Right  )

inline

        {   // replace [_Off, _Off + _N0) with _Right
        return (replace(_Off, _N0, _Right, 0, npos));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const size_type  _Off, size_type  _N0, const _Myt &  _Right, const size_type  _Roff, size_type  _Count = npos  )

inline

        {   // replace [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
        _Check_offset(_Off);
        _Right._Check_offset(_Roff);
        _N0 = _Clamp_suffix_size(_Off, _N0);
        _Count = _Right._Clamp_suffix_size(_Roff, _Count);
        if (npos - _Count <= this->_Mysize() - _N0)
            {
            _Xlen();    // result too long
            }

        const size_type _Nm = this->_Mysize() - _N0 - _Off; // length of kept tail
        const size_type _Newsize = this->_Mysize() + _Count - _N0;
        if (this->_Mysize() < _Newsize)
            {
            _Grow(_Newsize);
            }

        if (_Count == _N0)
            {   // only one movement required, so _Traits::move handles any overlap
            _Traits::move(this->_Myptr() + _Off,
                _Right._Myptr() + _Roff, _Count);   // fill hole
            }
        else if (this != _STD addressof(_Right))
            {   // no overlap, just move down and copy in new stuff
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off + _N0, _Nm);  // empty hole
            _Traits::copy(this->_Myptr() + _Off,
                _Right._Myptr() + _Roff, _Count);   // fill hole
            }
        else if (_Count < _N0)
            {   // hole doesn't get larger, just copy in substring
            _Traits::move(this->_Myptr() + _Off,
                this->_Myptr() + _Roff, _Count);    // fill hole
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off + _N0, _Nm);  // move tail down
            }
        else if (_Roff <= _Off)
            {   // hole gets larger, substring begins before hole
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off + _N0, _Nm);  // move tail down
            _Traits::move(this->_Myptr() + _Off,
                this->_Myptr() + _Roff, _Count);    // fill hole
            }
        else if (_Off + _N0 <= _Roff)
            {   // hole gets larger, substring begins after hole
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off + _N0, _Nm);  // move tail down
            _Traits::move(this->_Myptr() + _Off,
                this->_Myptr() + (_Roff + _Count - _N0),
                _Count);    // fill hole
            }
        else
            {   // hole gets larger, substring begins in hole
            _Traits::move(this->_Myptr() + _Off,
                this->_Myptr() + _Roff, _N0);   // fill old hole
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off + _N0, _Nm);  // move tail down
            _Traits::move(this->_Myptr() + _Off + _N0,
                this->_Myptr() + _Roff + _Count,
                _Count - _N0);  // fill rest of new hole
            }

        _Eos(_Newsize);
        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const size_type  _Off, size_type  _N0, _In_reads_(_Count) const _Elem *const  _Ptr, const size_type  _Count  )

inline

        {   // replace [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
        if (_Inside(_Ptr))
            {
            return (replace(_Off, _N0, *this,
                _Ptr - this->_Myptr(),
                _Count));   // substring, replace carefully
            }

        _Check_offset(_Off);
        _N0 = _Clamp_suffix_size(_Off, _N0);
        if (npos - _Count <= this->_Mysize() - _N0)
            {
            _Xlen();    // result too long
            }

        size_type _Nm = this->_Mysize() - _N0 - _Off;
        if (_Count < _N0)
            {
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off + _N0, _Nm);  // smaller hole, move tail up
            }

        const size_type _Num = this->_Mysize() + _Count - _N0;
        if ((_Count != 0 || _N0 != 0)
            && _Grow(_Num))
            {   // make room and rearrange
            if (_N0 < _Count)
                {
                _Traits::move(this->_Myptr() + _Off + _Count,
                    this->_Myptr() + _Off + _N0, _Nm);  // move tail down
                }
            _Traits::copy(this->_Myptr() + _Off, _Ptr, _Count); // fill hole
            _Eos(_Num);
            }

        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const size_type  _Off, const size_type  _N0, _In_z_ const _Elem *const  _Ptr  )

inline

        {   // replace [_Off, _Off + _N0) with [_Ptr, <null>)
        return (replace(_Off, _N0, _Ptr, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const size_type  _Off, size_type  _N0, const size_type  _Count, const _Elem  _Ch  )

inline

        {   // replace [_Off, _Off + _N0) with _Count * _Ch
        _Check_offset(_Off);
        _N0 = _Clamp_suffix_size(_Off, _N0);
        if (npos - _Count <= this->_Mysize() - _N0)
            {
            _Xlen();    // result too long
            }

        const size_type _Nm = this->_Mysize() - _N0 - _Off;
        if (_Count < _N0)
            {
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off + _N0, _Nm);  // smaller hole, move tail up
            }

        const size_type _Num = this->_Mysize() + _Count - _N0;
        if ((_Count != 0 || _N0 != 0) && _Grow(_Num))
            {   // make room and rearrange
            if (_N0 < _Count)
                {
                _Traits::move(this->_Myptr() + _Off + _Count,
                    this->_Myptr() + _Off + _N0, _Nm);  // move tail down
                }
            _Chassign(_Off, _Count, _Ch);   // fill hole
            _Eos(_Num);
            }
        return (*this);
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const const_iterator  _First, const const_iterator  _Last, const _Myt &  _Right  )

inline

        {   // replace [_First, _Last) with _Right
        return (replace(_First - begin(), _Last - _First, _Right));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const const_iterator  _First, const const_iterator  _Last, _In_reads_(_Count) const _Elem *const  _Ptr, const size_type  _Count  )

inline

        {   // replace [_First, _Last) with [_Ptr, _Ptr + _Count)
        return (replace(_First - begin(), _Last - _First, _Ptr, _Count));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const const_iterator  _First, const const_iterator  _Last, _In_z_ const _Elem *const  _Ptr  )

inline

        {   // replace [_First, _Last) with [_Ptr, <null>)
        return (replace(_First - begin(), _Last - _First, _Ptr));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const const_iterator  _First, const const_iterator  _Last, const size_type  _Count, const _Elem  _Ch  )

inline

        {   // replace [_First, _Last) with _Count * _Ch
        return (replace(_First - begin(), _Last - _First, _Count, _Ch));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

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

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( const const_iterator  _First, const const_iterator  _Last, const _Iter  _First2, const _Iter  _Last2  )

inline

        {   // replace [_First, _Last) with [_First2, _Last2), input iterators
        _DEBUG_RANGE(_First2, _Last2);
        const auto _UFirst2 = _Unchecked(_First2);
        const auto _ULast2 = _Unchecked(_Last2);
        return (_Replace_range(_First, _Last, _UFirst2, _ULast2, _Is_elem_cptr<decltype(_UFirst2)>()));
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::reserve ( _CRT_GUARDOVERFLOW const size_type  _Newcap = 0 )

inline

        {   // determine new minimum length of allocated storage
        auto& _My_data = this->_Get_data();
        if (_My_data._Mysize > _Newcap)
            {   // requested capacity is not large enough for current size, ignore
            return; // nothing to do
            }

        if (_My_data._Myres == _Newcap)
            {   // we're already at the requested capacity
            return; // nothing to do
            }

        if (_My_data._Myres < _Newcap)
            {   // reallocate to grow
            _Copy(_Newcap);
            return;
            }

        if (this->_BUF_SIZE > _Newcap && _My_data._Large_string_engaged())
            {   // deallocate everything; switch back to "small" mode
            this->_Orphan_all();
            pointer _Ptr = _My_data._Bx._Ptr;
            auto& _Al = this->_Getal();
            _Al.destroy(_STD addressof(_My_data._Bx._Ptr));
            _Traits::copy(_My_data._Bx._Buf, _Unfancy(_Ptr), _My_data._Mysize + 1);
            _Al.deallocate(_Ptr, _My_data._Myres + 1);
            _My_data._Myres = this->_BUF_SIZE - 1;
            return;
            }

        // ignore requests to reserve to [_BUF_SIZE, _Myres)
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::resize ( _CRT_GUARDOVERFLOW const size_type  _Newsize )

inline

        {   // determine new length, padding with null elements as needed
        resize(_Newsize, _Elem());
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::resize ( _CRT_GUARDOVERFLOW const size_type  _Newsize, const _Elem  _Ch  )

inline

        {   // determine new length, padding with _Ch elements as needed
        if (_Newsize <= this->_Mysize())
            {
            _Eos(_Newsize);
            }
        else
            {
            append(_Newsize - this->_Mysize(), _Ch);
            }
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

void basic_string< _Elem, _Traits, _Alloc >::shrink_to_fit ( )

inline

        {   // reduce capacity
        if ((size() | this->_ALLOC_MASK) < capacity())
            {   // worth shrinking, do it
            _Myt _Tmp(*this);
            swap(_Tmp);
            }
        }

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

size_type basic_string< _Elem, _Traits, _Alloc >::size ( ) const

inline

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

Member Data Documentation

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const size_type size_type basic_string< _Elem, _Traits, _Alloc >::_Count

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

const size_type basic_string< _Elem, _Traits, _Alloc >::_Dest_size

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

constexpr size_t basic_string< _Elem, _Traits, _Alloc >::_Memcpy_move_offset = offsetof(_Mydata_t, _Bx)

static

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

constexpr size_t basic_string< _Elem, _Traits, _Alloc >::_Memcpy_move_size = sizeof(_Mydata_t) - _Memcpy_move_offset

static

template<class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

_PGLOBAL const basic_string< _Elem, _Traits, _Alloc >::size_type basic_string< _Elem, _Traits, _Alloc >::npos

static

Initial value:

=
            (typename basic_string<_Elem, _Traits, _Alloc>::size_type)(-1)

---

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

• VS2017/inc/xstring