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<!is_empty< _Alloc >::value, _String_base_types< _Elem, _Alloc > >	_Mybase
typedef _Traits	traits_type
typedef _Alloc	allocator_type
typedef _Mybase::_Alty	_Alty
typedef _Mybase::value_type	value_type
typedef _Mybase::size_type	size_type
typedef _Mybase::difference_type	difference_type
typedef _Mybase::pointer	pointer
typedef _Mybase::const_pointer	const_pointer
typedef _Mybase::reference	reference
typedef _Mybase::const_reference	const_reference
typedef _Mybase::iterator	iterator
typedef _Mybase::const_iterator	const_iterator
typedef _STD reverse_iterator< iterator >	reverse_iterator
typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator
Public Types inherited from _String_alloc<!is_empty< _Alloc >::value, _String_base_types< _Elem, _Alloc > >
typedef _String_alloc< _Al_has_storage, _String_base_types< _Elem, _Alloc > >	_Myt
typedef _String_base_types< _Elem, _Alloc >::_Alloc	_Alloc
typedef _String_base_types< _Elem, _Alloc >::_Alty	_Alty
Public Types inherited from _String_val< _String_base_types< _Elem, _Alloc >::_Val_types >
enum
enum
typedef _String_val< _String_base_types< _Elem, _Alloc >::_Val_types >	_Myt
typedef _String_base_types< _Elem, _Alloc >::_Val_types::value_type	value_type
typedef _String_base_types< _Elem, _Alloc >::_Val_types::size_type	size_type
typedef _String_base_types< _Elem, _Alloc >::_Val_types::difference_type	difference_type
typedef _String_base_types< _Elem, _Alloc >::_Val_types::pointer	pointer
typedef _String_base_types< _Elem, _Alloc >::_Val_types::const_pointer	const_pointer
typedef _String_base_types< _Elem, _Alloc >::_Val_types::reference	reference
typedef _String_base_types< _Elem, _Alloc >::_Val_types::const_reference	const_reference
typedef _String_iterator< _Myt >	iterator
typedef _String_const_iterator< _Myt >	const_iterator

Public Member Functions
	basic_string (const _Myt &_Right)
	basic_string (const _Myt &_Right, const _Alloc &_Al)
	basic_string ()
	basic_string (const _Alloc &_Al)
	basic_string (const _Myt &_Right, size_type _Roff, size_type _Count=npos)
	basic_string (const _Myt &_Right, size_type _Roff, size_type _Count, const _Alloc &_Al)
	basic_string (const _Elem *_Ptr, size_type _Count)
	basic_string (const _Elem *_Ptr, size_type _Count, const _Alloc &_Al)
	basic_string (const _Elem *_Ptr)
	basic_string (const _Elem *_Ptr, const _Alloc &_Al)
	basic_string (size_type _Count, _Elem _Ch)
	basic_string (size_type _Count, _Elem _Ch, const _Alloc &_Al)
template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	basic_string (_Iter _First, _Iter _Last)
template<class _Iter , class = typename enable_if<_Is_iterator<_Iter>::value, void>::type>
	basic_string (_Iter _First, _Iter _Last, const _Alloc &_Al)
template<class _Iter >
void	_Construct (_Iter _First, _Iter _Last, input_iterator_tag)
template<class _Iter >
void	_Construct (_Iter _First, _Iter _Last, forward_iterator_tag)
	basic_string (const_pointer _First, const_pointer _Last)
	basic_string (const_pointer _First, const_pointer _Last, const _Alloc &_Al)
	basic_string (const_iterator _First, const_iterator _Last)
	basic_string (_Myt &&_Right) _NOEXCEPT
	basic_string (_Myt &&_Right, const _Alloc &_Al)
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT
_Myt &	assign (_Myt &&_Right) _NOEXCEPT
void	_Assign_rv (_Myt &&_Right)
	basic_string (_XSTD initializer_list< _Elem > _Ilist, const _Alloc &_Al=allocator_type())
_Myt &	operator= (_XSTD initializer_list< _Elem > _Ilist)
_Myt &	operator+= (_XSTD initializer_list< _Elem > _Ilist)
_Myt &	assign (_XSTD initializer_list< _Elem > _Ilist)
_Myt &	append (_XSTD initializer_list< _Elem > _Ilist)
iterator	insert (const_iterator _Where, _XSTD initializer_list< _Elem > _Ilist)
_Myt &	replace (const_iterator _First, const_iterator _Last, _XSTD initializer_list< _Elem > _Ilist)
	~basic_string () _NOEXCEPT
_Myt &	operator= (const _Myt &_Right)
_Myt &	operator= (const _Elem *_Ptr)
_Myt &	operator= (_Elem _Ch)
_Myt &	operator+= (const _Myt &_Right)
_Myt &	operator+= (const _Elem *_Ptr)
_Myt &	operator+= (_Elem _Ch)
_Myt &	append (const _Myt &_Right)
_Myt &	append (const _Myt &_Right, size_type _Roff, size_type _Count)
_Myt &	append (const _Elem *_Ptr, size_type _Count)
_Myt &	append (const _Elem *_Ptr)
_Myt &	append (size_type _Count, _Elem _Ch)
template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, _Myt & >::type	append (_Iter _First, _Iter _Last)
_Myt &	append (const_pointer _First, const_pointer _Last)
_Myt &	append (const_iterator _First, const_iterator _Last)
_Myt &	assign (const _Myt &_Right)
_Myt &	assign (const _Myt &_Right, size_type _Roff, size_type _Count)
_Myt &	assign (const _Elem *_Ptr, size_type _Count)
_Myt &	assign (const _Elem *_Ptr)
_Myt &	assign (size_type _Count, _Elem _Ch)
template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, _Myt & >::type	assign (_Iter _First, _Iter _Last)
_Myt &	assign (const_pointer _First, const_pointer _Last)
_Myt &	assign (const_iterator _First, const_iterator _Last)
_Myt &	insert (size_type _Off, const _Myt &_Right)
_Myt &	insert (size_type _Off, const _Myt &_Right, size_type _Roff, size_type _Count)
_Myt &	insert (size_type _Off, const _Elem *_Ptr, size_type _Count)
_Myt &	insert (size_type _Off, const _Elem *_Ptr)
_Myt &	insert (size_type _Off, size_type _Count, _Elem _Ch)
iterator	insert (const_iterator _Where)
iterator	insert (const_iterator _Where, _Elem _Ch)
iterator	insert (const_iterator _Where, size_type _Count, _Elem _Ch)
template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, iterator >::type	insert (const_iterator _Where, _Iter _First, _Iter _Last)
iterator	insert (const_iterator _Where, const_pointer _First, const_pointer _Last)
iterator	insert (const_iterator _Where, const_iterator _First, const_iterator _Last)
_Myt &	erase (size_type _Off=0)
_Myt &	erase (size_type _Off, size_type _Count)
iterator	erase (const_iterator _Where)
iterator	erase (const_iterator _First, const_iterator _Last)
void	clear () _NOEXCEPT
_Myt &	replace (size_type _Off, size_type _N0, const _Myt &_Right)
_Myt &	replace (size_type _Off, size_type _N0, const _Myt &_Right, size_type _Roff, size_type _Count)
_Myt &	replace (size_type _Off, size_type _N0, const _Elem *_Ptr, size_type _Count)
_Myt &	replace (size_type _Off, size_type _N0, const _Elem *_Ptr)
_Myt &	replace (size_type _Off, size_type _N0, size_type _Count, _Elem _Ch)
_Myt &	replace (const_iterator _First, const_iterator _Last, const _Myt &_Right)
_Myt &	replace (const_iterator _First, const_iterator _Last, const _Elem *_Ptr, size_type _Count)
_Myt &	replace (const_iterator _First, const_iterator _Last, const _Elem *_Ptr)
_Myt &	replace (const_iterator _First, const_iterator _Last, size_type _Count, _Elem _Ch)
template<class _Iter >
enable_if< _Is_iterator< _Iter >::value, _Myt & >::type	replace (const_iterator _First, const_iterator _Last, _Iter _First2, _Iter _Last2)
_Myt &	replace (const_iterator _First, const_iterator _Last, const_pointer _First2, const_pointer _Last2)
_Myt &	replace (const_iterator _First, const_iterator _Last, pointer _First2, pointer _Last2)
_Myt &	replace (const_iterator _First, const_iterator _Last, const_iterator _First2, const_iterator _Last2)
_Myt &	replace (const_iterator _First, const_iterator _Last, iterator _First2, iterator _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 (size_type _Off)
const_reference	at (size_type _Off) const
reference	operator[] (size_type _Off)
const_reference	operator[] (size_type _Off) const
void	push_back (_Elem _Ch)
void	pop_back ()
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
const _Elem *	c_str () const _NOEXCEPT
const _Elem *	data () const _NOEXCEPT
size_type	length () const _NOEXCEPT
size_type	size () const _NOEXCEPT
size_type	max_size () const _NOEXCEPT
void	resize (size_type _Newsize)
void	resize (size_type _Newsize, _Elem _Ch)
size_type	capacity () const _NOEXCEPT
void	reserve (size_type _Newcap=0)
bool	empty () const _NOEXCEPT
_SCL_INSECURE_DEPRECATE size_type	copy (_Elem *_Ptr, size_type _Count, size_type _Off=0) const
size_type	_Copy_s (_Elem *_Dest, size_type _Dest_size, size_type _Count, size_type _Off=0) const
void	_Swap_bx (_Myt &_Right)
void	swap (_Myt &_Right)
size_type	find (const _Myt &_Right, size_type _Off=0) const _NOEXCEPT
size_type	find (const _Elem *_Ptr, size_type _Off, size_type _Count) const
size_type	find (const _Elem *_Ptr, size_type _Off=0) const
size_type	find (_Elem _Ch, size_type _Off=0) const
size_type	rfind (const _Myt &_Right, size_type _Off=npos) const _NOEXCEPT
size_type	rfind (const _Elem *_Ptr, size_type _Off, size_type _Count) const
size_type	rfind (const _Elem *_Ptr, size_type _Off=npos) const
size_type	rfind (_Elem _Ch, size_type _Off=npos) const
size_type	find_first_of (const _Myt &_Right, size_type _Off=0) const _NOEXCEPT
size_type	find_first_of (const _Elem *_Ptr, size_type _Off, size_type _Count) const
size_type	find_first_of (const _Elem *_Ptr, size_type _Off=0) const
size_type	find_first_of (_Elem _Ch, size_type _Off=0) const
size_type	find_last_of (const _Myt &_Right, size_type _Off=npos) const _NOEXCEPT
size_type	find_last_of (const _Elem *_Ptr, size_type _Off, size_type _Count) const
size_type	find_last_of (const _Elem *_Ptr, size_type _Off=npos) const
size_type	find_last_of (_Elem _Ch, size_type _Off=npos) const
size_type	find_first_not_of (const _Myt &_Right, size_type _Off=0) const _NOEXCEPT
size_type	find_first_not_of (const _Elem *_Ptr, size_type _Off, size_type _Count) const
size_type	find_first_not_of (const _Elem *_Ptr, size_type _Off=0) const
size_type	find_first_not_of (_Elem _Ch, size_type _Off=0) const
size_type	find_last_not_of (const _Myt &_Right, size_type _Off=npos) const _NOEXCEPT
size_type	find_last_not_of (const _Elem *_Ptr, size_type _Off, size_type _Count) const
size_type	find_last_not_of (const _Elem *_Ptr, size_type _Off=npos) const
size_type	find_last_not_of (_Elem _Ch, size_type _Off=npos) const
_Myt	substr (size_type _Off=0, size_type _Count=npos) const
int	compare (const _Myt &_Right) const _NOEXCEPT
int	compare (size_type _Off, size_type _N0, const _Myt &_Right) const
int	compare (size_type _Off, size_type _N0, const _Myt &_Right, size_type _Roff, size_type _Count) const
int	compare (const _Elem *_Ptr) const
int	compare (size_type _Off, size_type _N0, const _Elem *_Ptr) const
int	compare (size_type _Off, size_type _N0, const _Elem *_Ptr, size_type _Count) const
allocator_type	get_allocator () const _NOEXCEPT
void	_Chassign (size_type _Off, size_type _Count, _Elem _Ch)
void	_Copy (size_type _Newsize, size_type _Oldlen)
void	_Eos (size_type _Newsize)
bool	_Grow (size_type _Newsize, bool _Trim=false)
bool	_Inside (const _Elem *_Ptr)
void	_Tidy (bool _Built=false, size_type _Newsize=0)
	__declspec (noreturn) void _Xlen() const
	__declspec (noreturn) void _Xran() const
Public Member Functions inherited from _String_alloc<!is_empty< _Alloc >::value, _String_base_types< _Elem, _Alloc > >
	_String_alloc (const _Alloc &_Al=_Alloc())
void	_Change_alloc (const _Alty &_Al)
void	_Swap_alloc (_Myt &_Right)
_Alty &	_Getal ()
const _Alty &	_Getal () const
Public Member Functions inherited from _String_val< _String_base_types< _Elem, _Alloc >::_Val_types >
	_String_val ()
value_type *	_Myptr ()
const value_type *	_Myptr () const
Public Member Functions inherited from _Container_base0
void	_Orphan_all ()
void	_Swap_all (_Container_base0 &)

Static Public Member Functions
static size_type	_Pdif (const_iterator _P2, const_iterator _P1)

Static Public Attributes
static _PGLOBAL const size_type	npos

Additional Inherited Members
Public Attributes inherited from _String_alloc<!is_empty< _Alloc >::value, _String_base_types< _Elem, _Alloc > >
_String_base_types< _Elem, _Alloc >::_Alty	_Alval
Public Attributes inherited from _String_val< _String_base_types< _Elem, _Alloc >::_Val_types >
union _String_val::_Bxty	_Bx
size_type	_Mysize
size_type	_Myres

Member Typedef Documentation

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

template<class _Elem, class _Traits, class _Alloc>

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

Constructor & Destructor Documentation

template<class _Elem, class _Traits, class _Alloc>

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

inline

        : _Mybase(_Right._Getal().select_on_container_copy_construction())


        {   // construct by copying _Right
        _Tidy();
        assign(_Right, 0, npos);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        : _Mybase(_Al)
        {   // construct by copying with allocator
        _Tidy();
        assign(_Right, 0, npos);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inlineexplicit

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        : _Mybase(_Right._Getal())
        {   // construct from _Right [_Roff, _Roff + _Count)
        _Tidy();
        assign(_Right, _Roff, _Count);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

basic_string< _Elem, _Traits, _Alloc >::basic_string ( _Iter  _First, _Iter  _Last  )

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

basic_string< _Elem, _Traits, _Alloc >::basic_string ( const_pointer  _First, const_pointer  _Last  )

inline

        : _Mybase()
        {   // construct from [_First, _Last), const pointers
        _DEBUG_RANGE(_First, _Last);
        _Tidy();
        if (_First != _Last)
            assign(&*_First, _Last - _First);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        : _Mybase(_Al)
        {   // construct from [_First, _Last), const pointers
        _DEBUG_RANGE(_First, _Last);
        _Tidy();
        if (_First != _Last)
            assign(&*_First, _Last - _First);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        : _Mybase()
        {   // construct from [_First, _Last), const_iterators
        _DEBUG_RANGE(_First, _Last);
        _Tidy();
        if (_First != _Last)
            assign(&*_First, _Last - _First);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        : _Mybase(_Al)
        {   // construct by moving _Right, allocator
        if (this->_Getal() != _Right._Getal())
            assign(_Right.begin(), _Right.end());
        else
            _Assign_rv(_STD forward<_Myt>(_Right));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // destroy the string
        _Tidy(true);
        }

Member Function Documentation

template<class _Elem, class _Traits, class _Alloc>

basic_string< _Elem, _Traits, _Alloc >::__declspec ( noreturn  ) const

inline

        {   // report a length_error
        _Xlength_error("string too long");
        }

template<class _Elem, class _Traits, class _Alloc>

basic_string< _Elem, _Traits, _Alloc >::__declspec ( noreturn  ) const

inline

        {   // report an out_of_range error
        _Xout_of_range("invalid string position");
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // assign by moving _Right
        if (_Right._Myres < this->_BUF_SIZE)
            _Traits::move(this->_Bx._Buf, _Right._Bx._Buf,
                _Right._Mysize + 1);
        else
            {   // copy pointer
            this->_Getal().construct(&this->_Bx._Ptr, _Right._Bx._Ptr);
            _Right._Bx._Ptr = pointer();
            }
        this->_Mysize = _Right._Mysize;
        this->_Myres = _Right._Myres;
        _Right._Tidy();
        }

template<class _Elem, class _Traits, class _Alloc>

void basic_string< _Elem, _Traits, _Alloc >::_Chassign ( size_type  _Off, size_type  _Count, _Elem  _Ch  )

inline

        {   // assign _Count copies of _Ch beginning at _Off
        if (_Count == 1)
            _Traits::assign(*(this->_Myptr() + _Off), _Ch);
        else
            _Traits::assign(this->_Myptr() + _Off, _Count, _Ch);
        }

template<class _Elem, class _Traits, class _Alloc>

template<class _Iter >

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

inline

        {   // initialize from [_First, _Last), input iterators
        _TRY_BEGIN
        for (; _First != _Last; ++_First)
            append((size_type)1, (_Elem)*_First);
        _CATCH_ALL
        _Tidy(true);
        _RERAISE;
        _CATCH_END
        }

template<class _Elem, class _Traits, class _Alloc>

template<class _Iter >

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

inline

        {   // initialize from [_First, _Last), forward iterators
        _DEBUG_RANGE(_First, _Last);
        size_type _Count = 0;
        _Distance(_First, _Last, _Count);
        reserve(_Count);

        _TRY_BEGIN
        for (; _First != _Last; ++_First)
            append((size_type)1, (_Elem)*_First);
        _CATCH_ALL
        _Tidy(true);
        _RERAISE;
        _CATCH_END
        }

template<class _Elem, class _Traits, class _Alloc>

void basic_string< _Elem, _Traits, _Alloc >::_Copy ( size_type  _Newsize, size_type  _Oldlen  )

inline

        {   // copy _Oldlen elements to newly allocated buffer
        size_type _Newres = _Newsize | this->_ALLOC_MASK;
        if (max_size() < _Newres)
            _Newres = _Newsize; // undo roundup if too big
        else if (this->_Myres / 2 <= _Newres / 3)
            ;
        else if (this->_Myres <= max_size() - this->_Myres / 2)
            _Newres = this->_Myres
                + this->_Myres / 2; // grow exponentially if possible
        else
            _Newres = max_size();   // settle for max_size()

        _Elem *_Ptr;
        _TRY_BEGIN
            _Ptr = this->_Getal().allocate(_Newres + 1);
        _CATCH_ALL
            _Newres = _Newsize; // allocation failed, undo roundup and retry
            _TRY_BEGIN
                _Ptr = this->_Getal().allocate(_Newres + 1);
            _CATCH_ALL
            _Tidy(true);    // failed again, discard storage and reraise
            _RERAISE;
            _CATCH_END
        _CATCH_END

        if (0 < _Oldlen)
            _Traits::copy(_Ptr, this->_Myptr(),
                _Oldlen);   // copy existing elements
        _Tidy(true);
        this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
        this->_Myres = _Newres;
        _Eos(_Oldlen);
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::_Copy_s ( _Elem *  _Dest, size_type  _Dest_size, size_type  _Count, size_type  _Off = 0  ) const

inline

        {   // copy [_Off, _Off + _Count) to [_Dest, _Dest + _Count)
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Dest);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        if (this->_Mysize - _Off < _Count)
            _Count = this->_Mysize - _Off;
        _Traits::_Copy_s(_Dest, _Dest_size, this->_Myptr() + _Off, _Count);
        return (_Count);
        }

template<class _Elem, class _Traits, class _Alloc>

void basic_string< _Elem, _Traits, _Alloc >::_Eos ( size_type  _Newsize )

inline

        {   // set new length and null terminator
        _Traits::assign(this->_Myptr()[this->_Mysize = _Newsize], _Elem());
        }

template<class _Elem, class _Traits, class _Alloc>

bool basic_string< _Elem, _Traits, _Alloc >::_Grow ( size_type  _Newsize, bool  _Trim = false  )

inline

        {   // ensure buffer is big enough, trim to size if _Trim is true
        if (max_size() < _Newsize)
            _Xlen();    // result too long
        if (this->_Myres < _Newsize)
            _Copy(_Newsize, this->_Mysize); // reallocate to grow
        else if (_Trim && _Newsize < this->_BUF_SIZE)
            _Tidy(true, // copy and deallocate if trimming to small string
                _Newsize < this->_Mysize ? _Newsize : this->_Mysize);
        else if (_Newsize == 0)
            _Eos(0);    // new size is zero, just null terminate
        return (0 < _Newsize);  // return true only if more work to do
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // test if _Ptr points inside string
        if (_Ptr == 0 || _Ptr < this->_Myptr()
            || this->_Myptr() + this->_Mysize <= _Ptr)
            return (false); // don't ask
        else
            return (true);
        }

template<class _Elem, class _Traits, class _Alloc>

static size_type basic_string< _Elem, _Traits, _Alloc >::_Pdif ( const_iterator  _P2, const_iterator  _P1  )

inlinestatic

        {   // compute safe iterator difference
        return (_STRING_ITER_BASE(_P2) == 0 ? 0 : _P2 - _P1);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // exchange _Bx with _Right._Bx
        if (this->_BUF_SIZE <= this->_Myres)
            if (this->_BUF_SIZE <= _Right._Myres)
                _Swap_adl(this->_Bx._Ptr, _Right._Bx._Ptr);
            else
                {   // swap large with small
                pointer _Ptr = this->_Bx._Ptr;
                this->_Getal().destroy(&this->_Bx._Ptr);
                _Traits::copy(this->_Bx._Buf,
                    _Right._Bx._Buf, _Right._Mysize + 1);
                this->_Getal().construct(&_Right._Bx._Ptr, _Ptr);
                }
        else
            if (_Right._Myres < this->_BUF_SIZE)
                _STD swap(this->_Bx._Buf, _Right._Bx._Buf);
            else
                {   // swap small with large
                pointer _Ptr = _Right._Bx._Ptr;
                this->_Getal().destroy(&_Right._Bx._Ptr);
                _Traits::copy(_Right._Bx._Buf,
                    this->_Bx._Buf, this->_Mysize + 1);
                this->_Getal().construct(&this->_Bx._Ptr, _Ptr);
                }
        }

template<class _Elem, class _Traits, class _Alloc>

void basic_string< _Elem, _Traits, _Alloc >::_Tidy ( bool  _Built = false, size_type  _Newsize = 0  )

inline

        {   // initialize buffer, deallocating any storage
        if (!_Built)
            ;
        else if (this->_BUF_SIZE <= this->_Myres)
            {   // copy any leftovers to small buffer and deallocate
            pointer _Ptr = this->_Bx._Ptr;
            this->_Getal().destroy(&this->_Bx._Ptr);
            if (0 < _Newsize)
                _Traits::copy(this->_Bx._Buf,
                    _STD addressof(*_Ptr), _Newsize);
            this->_Getal().deallocate(_Ptr, this->_Myres + 1);
            }
        this->_Myres = this->_BUF_SIZE - 1;
        _Eos(_Newsize);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // append _Right [_Roff, _Roff + _Count)
        if (_Right.size() < _Roff)
            _Xran();    // _Roff off end
        size_type _Num = _Right.size() - _Roff;
        if (_Num < _Count)
            _Count = _Num;  // trim _Count to size
        if (npos - this->_Mysize <= _Count)
            _Xlen();    // result too long

        if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
            {   // 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, class _Alloc>

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

inline

        {   // append [_Ptr, _Ptr + _Count)
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (_Inside(_Ptr))
            return (append(*this,
                _Ptr - this->_Myptr(), _Count));    // substring
        if (npos - this->_Mysize <= _Count)
            _Xlen();    // result too long

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

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

template<class _Elem, class _Traits, class _Alloc>

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, _Myt&>::type basic_string< _Elem, _Traits, _Alloc >::append ( _Iter  _First, _Iter  _Last  )

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // append [_First, _Last), const pointers
        return (replace(end(), end(), _First, _Last));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // assign by moving _Right
        if (this == &_Right)
            ;
        else if (get_allocator() != _Right.get_allocator()
            && this->_BUF_SIZE <= _Right._Myres)
            *this = _Right;
        else
            {   // not same, clear this and steal from _Right
            _Tidy(true);
            _Assign_rv(_STD forward<_Myt>(_Right));
            }
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // assign _Right [_Roff, _Roff + _Count)
        if (_Right.size() < _Roff)
            _Xran();    // _Roff off end
        size_type _Num = _Right.size() - _Roff;
        if (_Count < _Num)
            _Num = _Count;  // trim _Num to size

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // assign [_Ptr, _Ptr + _Count)
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        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, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

_Myt& basic_string< _Elem, _Traits, _Alloc >::assign ( size_type  _Count, _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, class _Alloc>

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, _Myt&>::type basic_string< _Elem, _Traits, _Alloc >::assign ( _Iter  _First, _Iter  _Last  )

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // assign [_First, _Last), const pointers
        return (replace(begin(), end(), _First, _Last));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // subscript mutable sequence with checking
        if (this->_Mysize <= _Off)
            _Xran();    // _Off off end
        return (this->_Myptr()[_Off]);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // subscript nonmutable sequence with checking
        if (this->_Mysize <= _Off)
            _Xran();    // _Off off end
        return (this->_Myptr()[_Off]);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return iterator for beginning of mutable sequence
        return (_STRING_ITERATOR(this->_Myptr()));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return iterator for beginning of nonmutable sequence
        return (_STRING_CONST_ITERATOR(this->_Myptr()));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return iterator for beginning of nonmutable sequence
        return (((const _Myt *)this)->begin());
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return iterator for end of nonmutable sequence
        return (((const _Myt *)this)->end());
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // erase all
        _Eos(0);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // compare [0, _Mysize) with _Right
        return (compare(0, this->_Mysize, _Right._Myptr(), _Right.size()));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

int basic_string< _Elem, _Traits, _Alloc >::compare ( size_type  _Off, size_type  _N0, const _Myt &  _Right, size_type  _Roff, size_type  _Count  ) const

inline

        {   // compare [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
        if (_Right.size() < _Roff)
            _Xran();    // _Off off end
        if (_Right._Mysize - _Roff < _Count)
            _Count = _Right._Mysize - _Roff;    // trim _Count to size
        return (compare(_Off, _N0, _Right._Myptr() + _Roff, _Count));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // compare [0, _Mysize) with [_Ptr, <null>)
        _DEBUG_POINTER(_Ptr);
        return (compare(0, this->_Mysize, _Ptr, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits, class _Alloc>

int basic_string< _Elem, _Traits, _Alloc >::compare ( size_type  _Off, size_type  _N0, const _Elem *  _Ptr  ) const

inline

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

template<class _Elem, class _Traits, class _Alloc>

int basic_string< _Elem, _Traits, _Alloc >::compare ( size_type  _Off, size_type  _N0, const _Elem *  _Ptr, size_type  _Count  ) const

inline

        {   // compare [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        if (this->_Mysize - _Off < _N0)
            _N0 = this->_Mysize - _Off; // trim _N0 to size

        size_type _Ans = _Traits::compare(this->_Myptr() + _Off, _Ptr,
            _N0 < _Count ? _N0 : _Count);
        return (_Ans != 0 ? (int)_Ans : _N0 < _Count ? -1
            : _N0 == _Count ? 0 : +1);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        if (this->_Mysize - _Off < _Count)
            _Count = this->_Mysize - _Off;
        _Traits::copy(_Ptr, this->_Myptr() + _Off, _Count);
        return (_Count);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return iterator for beginning of reversed nonmutable sequence
        return (((const _Myt *)this)->rbegin());
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return iterator for end of reversed nonmutable sequence
        return (((const _Myt *)this)->rend());
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return pointer to nonmutable array
        return (c_str());
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return iterator for end of mutable sequence
        return (_STRING_ITERATOR(this->_Myptr() + this->_Mysize));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // return iterator for end of nonmutable sequence
        return (_STRING_CONST_ITERATOR(this->_Myptr() + this->_Mysize));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // erase elements [_Off, ...)
        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        _Eos(_Off);
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // erase elements [_Off, _Off + _Count)
        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        if (this->_Mysize - _Off <= _Count)
            _Eos(_Off); // erase elements [_Off, ...)
        else if (0 < _Count)
            {   // 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, class _Alloc>

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

inline

        {   // erase element at _Where
        size_type _Count = _Pdif(_Where, begin());
        erase(_Count, 1);
        return (_STRING_ITERATOR(this->_Myptr() + _Count));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // erase substring [_First, _Last)
        _DEBUG_RANGE(_First, _Last);
        size_type _Count = _Pdif(_First, begin());
        erase(_Count, _Pdif(_Last, _First));
        return (_STRING_ITERATOR(this->_Myptr() + _Count));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // look for _Right beginning at or after _Off
        return (find(_Right._Myptr(), _Off, _Right.size()));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find ( const _Elem *  _Ptr, size_type  _Off, size_type  _Count  ) const

inline

        {   // look for [_Ptr, _Ptr + _Count) beginning at or after _Off
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (_Count == 0 && _Off <= this->_Mysize)
            return (_Off);  // null string always matches (if inside string)

        size_type _Nm;
        if (_Off < this->_Mysize && _Count <= (_Nm = this->_Mysize - _Off))
            {   // room for match, look for it
            const _Elem *_Uptr, *_Vptr;
            for (_Nm -= _Count - 1, _Vptr = this->_Myptr() + _Off;
                (_Uptr = _Traits::find(_Vptr, _Nm, *_Ptr)) != 0;
                _Nm -= _Uptr - _Vptr + 1, _Vptr = _Uptr + 1)
                if (_Traits::compare(_Uptr, _Ptr, _Count) == 0)
                    return (_Uptr - this->_Myptr());    // found a match
            }

        return (npos);  // no match
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // look for [_Ptr, <null>) beginning at or after _Off
        _DEBUG_POINTER(_Ptr);
        return (find(_Ptr, _Off, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find ( _Elem  _Ch, size_type  _Off = 0  ) const

inline

        {   // look for _Ch at or after _Off
        return (find((const _Elem *)&_Ch, _Off, 1));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // look for none of _Right at or after _Off
        return (find_first_not_of(_Right._Myptr(), _Off,
            _Right.size()));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_first_not_of ( const _Elem *  _Ptr, size_type  _Off, size_type  _Count  ) const

inline

        {   // look for none of [_Ptr, _Ptr + _Count) at or after _Off
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (_Off < this->_Mysize)
            {   // room for match, look for it
            const _Elem *const _Vptr = this->_Myptr() + this->_Mysize;
            for (const _Elem *_Uptr = this->_Myptr() + _Off;
                _Uptr < _Vptr; ++_Uptr)
                if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
                    return (_Uptr - this->_Myptr());
            }
        return (npos);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // look for one of [_Ptr, <null>) at or after _Off
        _DEBUG_POINTER(_Ptr);
        return (find_first_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_first_not_of ( _Elem  _Ch, size_type  _Off = 0  ) const

inline

        {   // look for non _Ch at or after _Off
        return (find_first_not_of((const _Elem *)&_Ch, _Off, 1));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // look for one of _Right at or after _Off
        return (find_first_of(_Right._Myptr(), _Off, _Right.size()));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_first_of ( const _Elem *  _Ptr, size_type  _Off, size_type  _Count  ) const

inline

        {   // look for one of [_Ptr, _Ptr + _Count) at or after _Off
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (0 < _Count && _Off < this->_Mysize)
            {   // room for match, look for it
            const _Elem *const _Vptr = this->_Myptr() + this->_Mysize;
            for (const _Elem *_Uptr = this->_Myptr() + _Off;
                _Uptr < _Vptr; ++_Uptr)
                if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
                    return (_Uptr - this->_Myptr());    // found a match
            }

        return (npos);  // no match
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // look for one of [_Ptr, <null>) at or after _Off
        _DEBUG_POINTER(_Ptr);
        return (find_first_of(_Ptr, _Off, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_first_of ( _Elem  _Ch, size_type  _Off = 0  ) const

inline

        {   // look for _Ch at or after _Off
        return (find((const _Elem *)&_Ch, _Off, 1));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // look for none of _Right before _Off
        return (find_last_not_of(_Right._Myptr(), _Off, _Right.size()));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_last_not_of ( const _Elem *  _Ptr, size_type  _Off, size_type  _Count  ) const

inline

        {   // look for none of [_Ptr, _Ptr + _Count) before _Off
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (0 < this->_Mysize)
            {   // worth searching, do it
            const _Elem *_Uptr = this->_Myptr()
                + (_Off < this->_Mysize ? _Off : this->_Mysize - 1);
            for (; ; --_Uptr)
                if (_Traits::find(_Ptr, _Count, *_Uptr) == 0)
                    return (_Uptr - this->_Myptr());
                else if (_Uptr == this->_Myptr())
                    break;
            }
        return (npos);
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_last_not_of ( const _Elem *  _Ptr, size_type  _Off = npos  ) const

inline

        {   // look for none of [_Ptr, <null>) before _Off
        _DEBUG_POINTER(_Ptr);
        return (find_last_not_of(_Ptr, _Off, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_last_not_of ( _Elem  _Ch, size_type  _Off = npos  ) const

inline

        {   // look for non _Ch before _Off
        return (find_last_not_of((const _Elem *)&_Ch, _Off, 1));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // look for one of _Right before _Off
        return (find_last_of(_Right._Myptr(), _Off, _Right.size()));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_last_of ( const _Elem *  _Ptr, size_type  _Off, size_type  _Count  ) const

inline

        {   // look for one of [_Ptr, _Ptr + _Count) before _Off
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (0 < _Count && 0 < this->_Mysize)
            {   // worth searching, do it
            const _Elem *_Uptr = this->_Myptr()
                + (_Off < this->_Mysize ? _Off : this->_Mysize - 1);
            for (; ; --_Uptr)
                if (_Traits::find(_Ptr, _Count, *_Uptr) != 0)
                    return (_Uptr - this->_Myptr());    // found a match
                else if (_Uptr == this->_Myptr())
                    break;  // at beginning, no more chance for match
            }

        return (npos);  // no match
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_last_of ( const _Elem *  _Ptr, size_type  _Off = npos  ) const

inline

        {   // look for one of [_Ptr, <null>) before _Off
        _DEBUG_POINTER(_Ptr);
        return (find_last_of(_Ptr, _Off, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::find_last_of ( _Elem  _Ch, size_type  _Off = npos  ) const

inline

        {   // look for _Ch before _Off
        return (rfind((const _Elem *)&_Ch, _Off, 1));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

allocator_type basic_string< _Elem, _Traits, _Alloc >::get_allocator ( ) const

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // insert _Right [_Roff, _Roff + _Count) at _Off
        if (this->_Mysize < _Off || _Right.size() < _Roff)
            _Xran();    // _Off or _Roff off end
        size_type _Num = _Right.size() - _Roff;
        if (_Num < _Count)
            _Count = _Num;  // trim _Count to size
        if (npos - this->_Mysize <= _Count)
            _Xlen();    // result too long

        if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
            {   // make room and insert new stuff
            _Traits::move(this->_Myptr() + _Off + _Count,
                this->_Myptr() + _Off,
                this->_Mysize - _Off);  // empty out hole
            if (this == &_Right)
                _Traits::move(this->_Myptr() + _Off,
                    this->_Myptr() + (_Off < _Roff ? _Roff + _Count : _Roff),
                        _Count);    // substring
            else
                _Traits::copy(this->_Myptr() + _Off,
                    _Right._Myptr() + _Roff, _Count);   // fill hole
            _Eos(_Num);
            }
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // insert [_Ptr, _Ptr + _Count) at _Off
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (_Inside(_Ptr))
            return (insert(_Off, *this,
                _Ptr - this->_Myptr(), _Count));    // substring
        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        if (npos - this->_Mysize <= _Count)
            _Xlen();    // result too long
        size_type _Num;
        if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
            {   // 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, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // insert _Count * _Ch at _Off
        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        if (npos - this->_Mysize <= _Count)
            _Xlen();    // result too long
        size_type _Num;
        if (0 < _Count && _Grow(_Num = this->_Mysize + _Count))
            {   // 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, class _Alloc>

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

inline

        {   // insert <null> at _Where
        return (insert(_Where, _Elem()));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, iterator>::type basic_string< _Elem, _Traits, _Alloc >::insert ( const_iterator  _Where, _Iter  _First, _Iter  _Last  )

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // insert [_First, _Last) at _Where, const_iterators
        size_type _Off = _Pdif(_Where, begin());
        replace(_Where, _Where, _First, _Last);
        return (begin() + _Off);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // append 1 * _Ch
        return (append((size_type)1, _Ch));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // different, assign it
            _Tidy(true);

            if (_Alty::propagate_on_container_move_assignment::value
                && this->_Getal() != _Right._Getal())
                this->_Change_alloc(_Right._Getal());

            if (this->_Getal() != _Right._Getal())
                assign(_Right.begin(), _Right.end());
            else
                _Assign_rv(_STD forward<_Myt>(_Right));
            }
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // assign _Right
        if (this != &_Right)
            {   // different, assign it
            if (this->_Getal() != _Right._Getal()
                && _Alty::propagate_on_container_copy_assignment::value)
                {   // change allocator before copying
                _Tidy(true);
                this->_Change_alloc(_Right._Getal());
                }

            assign(_Right);
            }
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // subscript mutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (this->_Mysize < _Off)   // sic
            _DEBUG_ERROR("string subscript out of range");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);  // sic
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        return (this->_Myptr()[_Off]);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // subscript nonmutable sequence
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (this->_Mysize < _Off)   // sic
            _DEBUG_ERROR("string subscript out of range");

 #elif _ITERATOR_DEBUG_LEVEL == 1
        _SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize);  // sic
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        return (this->_Myptr()[_Off]);
        }

template<class _Elem, class _Traits, class _Alloc>

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, class _Alloc>

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

inline

        {   // insert element at end
        insert(end(), _Ch);
        }

template<class _Elem, class _Traits, class _Alloc>

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, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

_Myt& basic_string< _Elem, _Traits, _Alloc >::replace ( size_type  _Off, 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, class _Alloc>

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

inline

        {   // replace [_Off, _Off + _N0) with _Right [_Roff, _Roff + _Count)
        if (this->_Mysize < _Off || _Right.size() < _Roff)
            _Xran();    // _Off or _Roff off end
        if (this->_Mysize - _Off < _N0)
            _N0 = this->_Mysize - _Off; // trim _N0 to size
        size_type _Num = _Right.size() - _Roff;
        if (_Num < _Count)
            _Count = _Num;  // trim _Count to size
        if (npos - _Count <= this->_Mysize - _N0)
            _Xlen();    // result too long

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

        if (this != &_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, class _Alloc>

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

inline

        {   // replace [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (_Inside(_Ptr))
            return (replace(_Off, _N0, *this,
                _Ptr - this->_Myptr(),
                _Count));   // substring, replace carefully
        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        if (this->_Mysize - _Off < _N0)
            _N0 = this->_Mysize - _Off; // trim _N0 to size
        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
        size_type _Num;
        if ((0 < _Count || 0 < _N0)
            && _Grow(_Num = this->_Mysize + _Count - _N0))
            {   // 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, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // replace [_Off, _Off + _N0) with _Count * _Ch
        if (this->_Mysize < _Off)
            _Xran();    // _Off off end
        if (this->_Mysize - _Off < _N0)
            _N0 = this->_Mysize - _Off; // trim _N0 to size
        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
        size_type _Num;
        if ((0 < _Count || 0 < _N0)
            && _Grow(_Num = this->_Mysize + _Count - _N0))
            {   // 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, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

template<class _Iter >

enable_if<_Is_iterator<_Iter>::value, _Myt&>::type basic_string< _Elem, _Traits, _Alloc >::replace ( const_iterator  _First, const_iterator  _Last, _Iter  _First2, _Iter  _Last2  )

inline

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

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // replace [_First, _Last) with [_First2, _Last2), const pointers
        if (_First2 == _Last2)
            erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
        else
            replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
                &*_First2, _Last2 - _First2);
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // replace [_First, _Last) with [_First2, _Last2), const pointers
        if (_First2 == _Last2)
            erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
        else
            replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
                &*_First2, _Last2 - _First2);
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // replace [_First, _Last) with [_First2, _Last2), const_iterators
        if (_First2 == _Last2)
            erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
        else
            replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
                &*_First2, _Last2 - _First2);
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // replace [_First, _Last) with [_First2, _Last2), const_iterators
        if (_First2 == _Last2)
            erase(_Pdif(_First, begin()), _Pdif(_Last, _First));
        else
            replace(_Pdif(_First, begin()), _Pdif(_Last, _First),
                &*_First2, _Last2 - _First2);
        return (*this);
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // determine new minimum length of allocated storage
        if (this->_Mysize <= _Newcap && this->_Myres != _Newcap)
            {   // change reservation
            size_type _Size = this->_Mysize;
            if (_Grow(_Newcap, true))
                _Eos(_Size);
            }
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

void basic_string< _Elem, _Traits, _Alloc >::resize ( size_type  _Newsize, _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, class _Alloc>

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

inline

        {   // look for _Right beginning before _Off
        return (rfind(_Right._Myptr(), _Off, _Right.size()));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::rfind ( const _Elem *  _Ptr, size_type  _Off, size_type  _Count  ) const

inline

        {   // look for [_Ptr, _Ptr + _Count) beginning before _Off
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Count != 0)
            _DEBUG_POINTER(_Ptr);
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        if (_Count == 0)
            return (_Off < this->_Mysize ? _Off
                : this->_Mysize);   // null always matches
        if (_Count <= this->_Mysize)
            {   // room for match, look for it
            const _Elem *_Uptr = this->_Myptr() +
                (_Off < this->_Mysize - _Count ? _Off
                    : this->_Mysize - _Count);
            for (; ; --_Uptr)
                if (_Traits::eq(*_Uptr, *_Ptr)
                    && _Traits::compare(_Uptr, _Ptr, _Count) == 0)
                    return (_Uptr - this->_Myptr());    // found a match
                else if (_Uptr == this->_Myptr())
                    break;  // at beginning, no more chance for match
            }

        return (npos);  // no match
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::rfind ( const _Elem *  _Ptr, size_type  _Off = npos  ) const

inline

        {   // look for [_Ptr, <null>) beginning before _Off
        _DEBUG_POINTER(_Ptr);
        return (rfind(_Ptr, _Off, _Traits::length(_Ptr)));
        }

template<class _Elem, class _Traits, class _Alloc>

size_type basic_string< _Elem, _Traits, _Alloc >::rfind ( _Elem  _Ch, size_type  _Off = npos  ) const

inline

        {   // look for _Ch before _Off
        return (rfind((const _Elem *)&_Ch, _Off, 1));
        }

template<class _Elem, class _Traits, class _Alloc>

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, class _Alloc>

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

inline

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

template<class _Elem, class _Traits, class _Alloc>

_Myt basic_string< _Elem, _Traits, _Alloc >::substr ( size_type  _Off = 0, size_type  _Count = npos  ) const

inline

        {   // return [_Off, _Off + _Count) as new string
        return (_Myt(*this, _Off, _Count, get_allocator()));
        }

template<class _Elem, class _Traits, class _Alloc>

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

inline

        {   // exchange contents with _Right
        if (this == &_Right)
            ;   // same object, do nothing
        else if (this->_Getal() == _Right._Getal())
            {   // same allocator, swap control information
            this->_Swap_all(_Right);
            _Swap_bx(_Right);
            _STD swap(this->_Mysize, _Right._Mysize);
            _STD swap(this->_Myres, _Right._Myres);
            }

        else if (_Alty::propagate_on_container_swap::value)
            {   // swap allocators and control information
            this->_Swap_alloc(_Right);
            _Swap_bx(_Right);
            _STD swap(this->_Bx, _Right._Bx);   // pointer bitwise copyable?
            _STD swap(this->_Mysize, _Right._Mysize);
            _STD swap(this->_Myres, _Right._Myres);
            }

        else
            {   // different allocator, do multiple assigns
            _Myt _Tmp = *this;

            *this = _Right;
            _Right = _Tmp;
            }
        }

Member Data Documentation

template<class _Elem, class _Traits, class _Alloc>

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

• VS2013/inc/xstring