NIM 跨平台 C++ SDK
载入中...
搜索中...
未找到
Public 类型 | Public 成员函数 | Private 类型 | Private 成员函数 | Private 属性 | 友元 | 所有成员列表
nstd::_string< _malloc, _delete > 模板类 参考

#include <ne_stl_string.h>

Public 类型

using value_type = char
 

Public 成员函数

 _string ()
 
 _string (const _string &other)
 
 _string (const _string &other, std::size_t pos, std::size_t len=container_npos::value)
 
 _string (const char *copy)
 
 _string (const char *s, std::size_t n)
 
 _string (std::size_t n, char c)
 
 _string (const const_iterator first, const const_iterator second)
 
 _string (const std::string &other)
 
 _string (_string &&other)
 
_string & operator= (const char *other)
 
_string & operator= (const _string &other)
 
_string & operator= (const std::string &std_string)
 
 operator std::string () const
 
 ~_string ()
 
const char & operator[] (std::size_t i) const
 
char & operator[] (std::size_t i)
 
const char & at (std::size_t i) const
 
char & at (std::size_t i)
 
const char & front () const
 
char & front ()
 
const char & back () const
 
char & back ()
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
reverse_iterator rbegin ()
 
const_reverse_iterator rbegin () const
 
reverse_iterator rend ()
 
const_reverse_iterator rend () const
 
const_reverse_iterator crbegin () const
 
const_reverse_iterator crend () const
 
_string & operator+= (const _string &s)
 
_string & operator+= (const char *s)
 
_string & operator+= (char c)
 
_string operator+ (const _string &s) const
 
_string operator+ (const char *s) const
 
_string operator+ (char c) const
 
_string & append (const _string &other)
 
_string & append (const _string &other, std::size_t subpos, std::size_t sublen=container_npos::value)
 
_string & append (const char *other)
 
_string & append (const char *s, std::size_t n)
 
_string & append (std::size_t n, char c)
 
_string & append (const const_iterator first, const const_iterator second)
 
_string & push_back (char c)
 
_string & insert (std::size_t pos, const _string &other)
 
_string & insert (std::size_t pos, const _string &other, std::size_t subpos, std::size_t sublen=container_npos::value)
 
_string & insert (std::size_t pos, const char *other)
 
_string & insert (std::size_t pos, const char *s, std::size_t n)
 
_string & insert (std::size_t pos, std::size_t n, char c)
 
void insert (iterator p, std::size_t n, char c)
 
iterator insert (iterator p, char c)
 
void insert (iterator p, const const_iterator begin, const const_iterator last)
 
_string & erase (std::size_t pos=0, std::size_t len=container_npos::value)
 
iterator erase (const_iterator p)
 
iterator erase (const_iterator first, const_iterator last)
 
_string & replace (std::size_t pos, std::size_t len, const _string &other)
 
_string & replace (const_iterator i1, const_iterator i2, const _string &other)
 
_string & replace (std::size_t pos, std::size_t len, const _string &other, std::size_t subpos, std::size_t sublen=container_npos::value)
 
_string & replace (std::size_t pos, std::size_t len, const char *s)
 
_string & replace (const_iterator i1, const_iterator i2, const char *other)
 
_string & replace (std::size_t pos, std::size_t len, const char *other, std::size_t n)
 
_string & replace (const_iterator i1, const_iterator i2, const char *other, std::size_t n)
 
_string & replace (std::size_t pos, std::size_t len, std::size_t n, char c)
 
_string & replace (const_iterator i1, const_iterator i2, std::size_t n, char c)
 
_string & replace (const_iterator i1, const_iterator i2, const_iterator first, const_iterator second)
 
void swap (_string &other)
 
_string & pop_back ()
 
const char * c_str () const
 
std::size_t copy (char *s, std::size_t len, std::size_t pos=0) const
 
std::size_t find (const _string &other, std::size_t pos=0) const
 
std::size_t find (const char *s, std::size_t pos=0) const
 
std::size_t find (const char *s, std::size_t pos, std::size_t n) const
 
std::size_t find (char c, std::size_t pos=0) const
 
std::size_t rfind (const _string &other, std::size_t pos=container_npos::value) const
 
std::size_t rfind (const char *s, std::size_t pos=container_npos::value) const
 
std::size_t rfind (const char *s, std::size_t pos, std::size_t n) const
 
std::size_t rfind (char c, std::size_t pos=container_npos::value) const
 
std::size_t find_first_of (const _string &other, std::size_t pos=0) const
 
std::size_t find_first_of (const char *other, std::size_t pos=0) const
 
std::size_t find_first_of (const char *other, std::size_t pos, std::size_t n) const
 
std::size_t find_first_of (char c, std::size_t pos=0) const
 
std::size_t find_last_of (const _string &other, std::size_t pos=nstd::container_npos::value) const
 
std::size_t find_last_of (const char *other, std::size_t pos=nstd::container_npos::value) const
 
std::size_t find_last_of (const char *other, std::size_t pos, std::size_t n) const
 
std::size_t find_last_of (char c, std::size_t pos=nstd::container_npos::value) const
 
std::size_t find_first_not_of (const _string &other, std::size_t pos=0) const
 
std::size_t find_first_not_of (const char *other, std::size_t pos=0) const
 
std::size_t find_first_not_of (const char *other, std::size_t pos, std::size_t n) const
 
std::size_t find_first_not_of (char c, std::size_t pos=0) const
 
std::size_t find_last_not_of (const _string &other, std::size_t pos=nstd::container_npos::value) const
 
std::size_t find_last_not_of (const char *other, std::size_t pos=nstd::container_npos::value) const
 
std::size_t find_last_not_of (const char *other, std::size_t pos, std::size_t n) const
 
std::size_t find_last_not_of (char c, std::size_t pos=nstd::container_npos::value) const
 
_string substr (std::size_t pos=0, std::size_t len=container_npos::value) const
 
std::size_t length () const
 
std::size_t size () const
 
std::size_t max_size () const
 
void resize (std::size_t n)
 
void resize (std::size_t n, char c)
 
std::size_t capacity () const
 
void reserve (std::size_t n=0)
 
void clear ()
 
bool empty () const
 
void shrink_to_fit ()
 

Private 类型

using string_iterator_type = nstd::iterator_type< char >
 
using const_iterator = nstd::const_iterator< char >
 
using iterator = nstd::iterator< char >
 
using reverse_iterator = nstd::reverse_iterator< char >
 
using const_reverse_iterator = nstd::const_reverse_iterator< char >
 

Private 成员函数

int32_t _compare (const _string &rhs) const
 
string_iterator_type _ibegin () const
 
string_iterator_type _rbegin () const
 
string_iterator_type _end () const
 
std::size_t _getLength (const const_iterator first, const const_iterator second)
 
void _append (const char *other)
 
void _append (const char *other, std::size_t n)
 
void _insert_str (std::size_t pos, const char *other)
 
void _insert_str (std::size_t pos, const char *other, std::size_t n)
 
void _substr (char *&buffer, const char *other, std::size_t pos=0, std::size_t len=container_npos::value) const
 
void _erase (std::size_t pos, std::size_t len)
 
void _replace (std::size_t pos, std::size_t len, const char *other, std::size_t n)
 
std::size_t _getLength (const _string &str, std::size_t pos, std::size_t len=container_npos::value) const
 
std::size_t _find (const char *other, std::size_t len, std::size_t pos) const
 
std::size_t _rfind (const char *other, std::size_t len, std::size_t pos) const
 
bool _find_compare (const char *other, std::size_t len, std::size_t pos) const
 
std::size_t _find_first_of (const char *other, std::size_t len, std::size_t pos, bool isTrue) const
 
std::size_t _find_last_of (const char *other, std::size_t len, std::size_t pos, bool isTrue) const
 
bool _find_of_compare (const char *other, std::size_t len, std::size_t pos, bool isTrue) const
 
void _setLength (const std::size_t len)
 
void _setCapacity (const std::size_t cap)
 
void _increaseCapacity (const std::size_t cap)
 
void _decreaseCapacity (const std::size_t cap)
 
void _alloc_cstring (char *&buffer, const std::size_t n) const
 
void _alloc_cstring (char *&buffer, const std::size_t n, char c) const
 
void _alloc_cstring (char *&buffer, const std::size_t n, const const_iterator i1, const const_iterator i2) const
 
void _fill_str (char *other, const std::size_t len, std::size_t pos, char c) const
 
void _clear_str (const std::size_t pos)
 
char * _new_data (std::size_t count) const
 
void _delete_data (char *&data) const
 

Private 属性

char * _str
 
std::size_t _str_len
 
std::size_t _str_cap
 
std::size_t _increaseBy = container_increase_step::value
 
element_malloc_fun_t< char > malloc_fun_
 
element_delete_fun_t< char > delete_fun_
 

友元

bool operator== (const _string &lhs, const _string &rhs)
 
bool operator!= (const _string &lhs, const _string &rhs)
 
bool operator< (const _string &lhs, const _string &rhs)
 
bool operator> (const _string &lhs, const _string &rhs)
 
bool operator<= (const _string &lhs, const _string &rhs)
 
bool operator>= (const _string &lhs, const _string &rhs)
 

成员类型定义说明

◆ const_iterator

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
using nstd::_string< _malloc, _delete >::const_iterator = nstd::const_iterator<char>
private

◆ const_reverse_iterator

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
using nstd::_string< _malloc, _delete >::const_reverse_iterator = nstd::const_reverse_iterator<char>
private

◆ iterator

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
using nstd::_string< _malloc, _delete >::iterator = nstd::iterator<char>
private

◆ reverse_iterator

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
using nstd::_string< _malloc, _delete >::reverse_iterator = nstd::reverse_iterator<char>
private

◆ string_iterator_type

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
using nstd::_string< _malloc, _delete >::string_iterator_type = nstd::iterator_type<char>
private

◆ value_type

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
using nstd::_string< _malloc, _delete >::value_type = char

构造及析构函数说明

◆ _string() [1/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( )
inline

◆ _string() [2/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( const _string< _malloc, _delete > &  other)
inline

◆ _string() [3/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( const _string< _malloc, _delete > &  other,
std::size_t  pos,
std::size_t  len = container_npos::value 
)
inline

◆ _string() [4/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( const char *  copy)
inline

◆ _string() [5/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( const char *  s,
std::size_t  n 
)
inline

◆ _string() [6/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( std::size_t  n,
char  c 
)
inline

◆ _string() [7/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( const const_iterator  first,
const const_iterator  second 
)
inline

◆ _string() [8/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( const std::string &  other)
inline

◆ _string() [9/9]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::_string ( _string< _malloc, _delete > &&  other)
inline

◆ ~_string()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::~_string ( )
inline

成员函数说明

◆ _alloc_cstring() [1/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_alloc_cstring ( char *&  buffer,
const std::size_t  n 
) const
inlineprivate

◆ _alloc_cstring() [2/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_alloc_cstring ( char *&  buffer,
const std::size_t  n,
char  c 
) const
inlineprivate

◆ _alloc_cstring() [3/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_alloc_cstring ( char *&  buffer,
const std::size_t  n,
const const_iterator  i1,
const const_iterator  i2 
) const
inlineprivate

◆ _append() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_append ( const char *  other)
inlineprivate

◆ _append() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_append ( const char *  other,
std::size_t  n 
)
inlineprivate

◆ _clear_str()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_clear_str ( const std::size_t  pos)
inlineprivate

◆ _compare()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
int32_t nstd::_string< _malloc, _delete >::_compare ( const _string< _malloc, _delete > &  rhs) const
inlineprivate

◆ _decreaseCapacity()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_decreaseCapacity ( const std::size_t  cap)
inlineprivate

◆ _delete_data()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_delete_data ( char *&  data) const
inlineprivate

◆ _end()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
string_iterator_type nstd::_string< _malloc, _delete >::_end ( ) const
inlineprivate

◆ _erase()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_erase ( std::size_t  pos,
std::size_t  len 
)
inlineprivate

◆ _fill_str()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_fill_str ( char *  other,
const std::size_t  len,
std::size_t  pos,
char  c 
) const
inlineprivate

◆ _find()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_find ( const char *  other,
std::size_t  len,
std::size_t  pos 
) const
inlineprivate

◆ _find_compare()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool nstd::_string< _malloc, _delete >::_find_compare ( const char *  other,
std::size_t  len,
std::size_t  pos 
) const
inlineprivate

◆ _find_first_of()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_find_first_of ( const char *  other,
std::size_t  len,
std::size_t  pos,
bool  isTrue 
) const
inlineprivate

◆ _find_last_of()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_find_last_of ( const char *  other,
std::size_t  len,
std::size_t  pos,
bool  isTrue 
) const
inlineprivate

◆ _find_of_compare()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool nstd::_string< _malloc, _delete >::_find_of_compare ( const char *  other,
std::size_t  len,
std::size_t  pos,
bool  isTrue 
) const
inlineprivate

◆ _getLength() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_getLength ( const _string< _malloc, _delete > &  str,
std::size_t  pos,
std::size_t  len = container_npos::value 
) const
inlineprivate

◆ _getLength() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_getLength ( const const_iterator  first,
const const_iterator  second 
)
inlineprivate

◆ _ibegin()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
string_iterator_type nstd::_string< _malloc, _delete >::_ibegin ( ) const
inlineprivate

◆ _increaseCapacity()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_increaseCapacity ( const std::size_t  cap)
inlineprivate

◆ _insert_str() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_insert_str ( std::size_t  pos,
const char *  other 
)
inlineprivate

◆ _insert_str() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_insert_str ( std::size_t  pos,
const char *  other,
std::size_t  n 
)
inlineprivate

◆ _new_data()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
char * nstd::_string< _malloc, _delete >::_new_data ( std::size_t  count) const
inlineprivate

◆ _rbegin()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
string_iterator_type nstd::_string< _malloc, _delete >::_rbegin ( ) const
inlineprivate

◆ _replace()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_replace ( std::size_t  pos,
std::size_t  len,
const char *  other,
std::size_t  n 
)
inlineprivate

◆ _rfind()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_rfind ( const char *  other,
std::size_t  len,
std::size_t  pos 
) const
inlineprivate

◆ _setCapacity()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_setCapacity ( const std::size_t  cap)
inlineprivate

◆ _setLength()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_setLength ( const std::size_t  len)
inlineprivate

◆ _substr()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::_substr ( char *&  buffer,
const char *  other,
std::size_t  pos = 0,
std::size_t  len = container_npos::value 
) const
inlineprivate

◆ append() [1/6]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::append ( const _string< _malloc, _delete > &  other)
inline

◆ append() [2/6]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::append ( const _string< _malloc, _delete > &  other,
std::size_t  subpos,
std::size_t  sublen = container_npos::value 
)
inline

◆ append() [3/6]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::append ( const char *  other)
inline

◆ append() [4/6]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::append ( const char *  s,
std::size_t  n 
)
inline

◆ append() [5/6]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::append ( const const_iterator  first,
const const_iterator  second 
)
inline

◆ append() [6/6]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::append ( std::size_t  n,
char  c 
)
inline

◆ at() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
char & nstd::_string< _malloc, _delete >::at ( std::size_t  i)
inline

◆ at() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const char & nstd::_string< _malloc, _delete >::at ( std::size_t  i) const
inline

◆ back() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
char & nstd::_string< _malloc, _delete >::back ( )
inline

◆ back() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const char & nstd::_string< _malloc, _delete >::back ( ) const
inline

◆ begin() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
iterator nstd::_string< _malloc, _delete >::begin ( )
inline

◆ begin() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const_iterator nstd::_string< _malloc, _delete >::begin ( ) const
inline

◆ c_str()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const char * nstd::_string< _malloc, _delete >::c_str ( ) const
inline

◆ capacity()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::capacity ( ) const
inline

◆ cbegin()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const_iterator nstd::_string< _malloc, _delete >::cbegin ( ) const
inline

◆ cend()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const_iterator nstd::_string< _malloc, _delete >::cend ( ) const
inline

◆ clear()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::clear ( )
inline

◆ copy()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::copy ( char *  s,
std::size_t  len,
std::size_t  pos = 0 
) const
inline

◆ crbegin()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const_reverse_iterator nstd::_string< _malloc, _delete >::crbegin ( ) const
inline

◆ crend()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const_reverse_iterator nstd::_string< _malloc, _delete >::crend ( ) const
inline

◆ empty()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool nstd::_string< _malloc, _delete >::empty ( ) const
inline

◆ end() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
iterator nstd::_string< _malloc, _delete >::end ( )
inline

◆ end() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const_iterator nstd::_string< _malloc, _delete >::end ( ) const
inline

◆ erase() [1/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
iterator nstd::_string< _malloc, _delete >::erase ( const_iterator  first,
const_iterator  last 
)
inline

◆ erase() [2/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
iterator nstd::_string< _malloc, _delete >::erase ( const_iterator  p)
inline

◆ erase() [3/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::erase ( std::size_t  pos = 0,
std::size_t  len = container_npos::value 
)
inline

◆ find() [1/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find ( char  c,
std::size_t  pos = 0 
) const
inline

◆ find() [2/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find ( const _string< _malloc, _delete > &  other,
std::size_t  pos = 0 
) const
inline

◆ find() [3/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find ( const char *  s,
std::size_t  pos,
std::size_t  n 
) const
inline

◆ find() [4/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find ( const char *  s,
std::size_t  pos = 0 
) const
inline

◆ find_first_not_of() [1/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_first_not_of ( char  c,
std::size_t  pos = 0 
) const
inline

◆ find_first_not_of() [2/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_first_not_of ( const _string< _malloc, _delete > &  other,
std::size_t  pos = 0 
) const
inline

◆ find_first_not_of() [3/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_first_not_of ( const char *  other,
std::size_t  pos,
std::size_t  n 
) const
inline

◆ find_first_not_of() [4/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_first_not_of ( const char *  other,
std::size_t  pos = 0 
) const
inline

◆ find_first_of() [1/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_first_of ( char  c,
std::size_t  pos = 0 
) const
inline

◆ find_first_of() [2/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_first_of ( const _string< _malloc, _delete > &  other,
std::size_t  pos = 0 
) const
inline

◆ find_first_of() [3/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_first_of ( const char *  other,
std::size_t  pos,
std::size_t  n 
) const
inline

◆ find_first_of() [4/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_first_of ( const char *  other,
std::size_t  pos = 0 
) const
inline

◆ find_last_not_of() [1/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_last_not_of ( char  c,
std::size_t  pos = nstd::container_npos::value 
) const
inline

◆ find_last_not_of() [2/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_last_not_of ( const _string< _malloc, _delete > &  other,
std::size_t  pos = nstd::container_npos::value 
) const
inline

◆ find_last_not_of() [3/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_last_not_of ( const char *  other,
std::size_t  pos,
std::size_t  n 
) const
inline

◆ find_last_not_of() [4/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_last_not_of ( const char *  other,
std::size_t  pos = nstd::container_npos::value 
) const
inline

◆ find_last_of() [1/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_last_of ( char  c,
std::size_t  pos = nstd::container_npos::value 
) const
inline

◆ find_last_of() [2/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_last_of ( const _string< _malloc, _delete > &  other,
std::size_t  pos = nstd::container_npos::value 
) const
inline

◆ find_last_of() [3/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_last_of ( const char *  other,
std::size_t  pos,
std::size_t  n 
) const
inline

◆ find_last_of() [4/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::find_last_of ( const char *  other,
std::size_t  pos = nstd::container_npos::value 
) const
inline

◆ front() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
char & nstd::_string< _malloc, _delete >::front ( )
inline

◆ front() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const char & nstd::_string< _malloc, _delete >::front ( ) const
inline

◆ insert() [1/8]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
iterator nstd::_string< _malloc, _delete >::insert ( iterator  p,
char  c 
)
inline

◆ insert() [2/8]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::insert ( iterator  p,
const const_iterator  begin,
const const_iterator  last 
)
inline

◆ insert() [3/8]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::insert ( iterator  p,
std::size_t  n,
char  c 
)
inline

◆ insert() [4/8]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::insert ( std::size_t  pos,
const _string< _malloc, _delete > &  other 
)
inline

◆ insert() [5/8]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::insert ( std::size_t  pos,
const _string< _malloc, _delete > &  other,
std::size_t  subpos,
std::size_t  sublen = container_npos::value 
)
inline

◆ insert() [6/8]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::insert ( std::size_t  pos,
const char *  other 
)
inline

◆ insert() [7/8]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::insert ( std::size_t  pos,
const char *  s,
std::size_t  n 
)
inline

◆ insert() [8/8]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::insert ( std::size_t  pos,
std::size_t  n,
char  c 
)
inline

◆ length()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::length ( ) const
inline

◆ max_size()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::max_size ( ) const
inline

◆ operator std::string()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
nstd::_string< _malloc, _delete >::operator std::string ( ) const
inline

◆ operator+() [1/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string nstd::_string< _malloc, _delete >::operator+ ( char  c) const
inline

◆ operator+() [2/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string nstd::_string< _malloc, _delete >::operator+ ( const _string< _malloc, _delete > &  s) const
inline

◆ operator+() [3/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string nstd::_string< _malloc, _delete >::operator+ ( const char *  s) const
inline

◆ operator+=() [1/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::operator+= ( char  c)
inline

◆ operator+=() [2/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::operator+= ( const _string< _malloc, _delete > &  s)
inline

◆ operator+=() [3/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::operator+= ( const char *  s)
inline

◆ operator=() [1/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::operator= ( const _string< _malloc, _delete > &  other)
inline

◆ operator=() [2/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::operator= ( const char *  other)
inline

◆ operator=() [3/3]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::operator= ( const std::string &  std_string)
inline

◆ operator[]() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
char & nstd::_string< _malloc, _delete >::operator[] ( std::size_t  i)
inline

◆ operator[]() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const char & nstd::_string< _malloc, _delete >::operator[] ( std::size_t  i) const
inline

◆ pop_back()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::pop_back ( )
inline

◆ push_back()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::push_back ( char  c)
inline

◆ rbegin() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
reverse_iterator nstd::_string< _malloc, _delete >::rbegin ( )
inline

◆ rbegin() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const_reverse_iterator nstd::_string< _malloc, _delete >::rbegin ( ) const
inline

◆ rend() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
reverse_iterator nstd::_string< _malloc, _delete >::rend ( )
inline

◆ rend() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
const_reverse_iterator nstd::_string< _malloc, _delete >::rend ( ) const
inline

◆ replace() [1/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( const_iterator  i1,
const_iterator  i2,
const _string< _malloc, _delete > &  other 
)
inline

◆ replace() [2/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( const_iterator  i1,
const_iterator  i2,
const char *  other 
)
inline

◆ replace() [3/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( const_iterator  i1,
const_iterator  i2,
const char *  other,
std::size_t  n 
)
inline

◆ replace() [4/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( const_iterator  i1,
const_iterator  i2,
const_iterator  first,
const_iterator  second 
)
inline

◆ replace() [5/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( const_iterator  i1,
const_iterator  i2,
std::size_t  n,
char  c 
)
inline

◆ replace() [6/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( std::size_t  pos,
std::size_t  len,
const _string< _malloc, _delete > &  other 
)
inline

◆ replace() [7/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( std::size_t  pos,
std::size_t  len,
const _string< _malloc, _delete > &  other,
std::size_t  subpos,
std::size_t  sublen = container_npos::value 
)
inline

◆ replace() [8/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( std::size_t  pos,
std::size_t  len,
const char *  other,
std::size_t  n 
)
inline

◆ replace() [9/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( std::size_t  pos,
std::size_t  len,
const char *  s 
)
inline

◆ replace() [10/10]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string & nstd::_string< _malloc, _delete >::replace ( std::size_t  pos,
std::size_t  len,
std::size_t  n,
char  c 
)
inline

◆ reserve()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::reserve ( std::size_t  n = 0)
inline

◆ resize() [1/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::resize ( std::size_t  n)
inline

◆ resize() [2/2]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::resize ( std::size_t  n,
char  c 
)
inline

◆ rfind() [1/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::rfind ( char  c,
std::size_t  pos = container_npos::value 
) const
inline

◆ rfind() [2/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::rfind ( const _string< _malloc, _delete > &  other,
std::size_t  pos = container_npos::value 
) const
inline

◆ rfind() [3/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::rfind ( const char *  s,
std::size_t  pos,
std::size_t  n 
) const
inline

◆ rfind() [4/4]

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::rfind ( const char *  s,
std::size_t  pos = container_npos::value 
) const
inline

◆ shrink_to_fit()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::shrink_to_fit ( )
inline

◆ size()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::size ( ) const
inline

◆ substr()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
_string nstd::_string< _malloc, _delete >::substr ( std::size_t  pos = 0,
std::size_t  len = container_npos::value 
) const
inline

◆ swap()

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
void nstd::_string< _malloc, _delete >::swap ( _string< _malloc, _delete > &  other)
inline

友元及相关函数文档

◆ operator!=

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool operator!= ( const _string< _malloc, _delete > &  lhs,
const _string< _malloc, _delete > &  rhs 
)
friend

◆ operator<

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool operator< ( const _string< _malloc, _delete > &  lhs,
const _string< _malloc, _delete > &  rhs 
)
friend

◆ operator<=

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool operator<= ( const _string< _malloc, _delete > &  lhs,
const _string< _malloc, _delete > &  rhs 
)
friend

◆ operator==

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool operator== ( const _string< _malloc, _delete > &  lhs,
const _string< _malloc, _delete > &  rhs 
)
friend

◆ operator>

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool operator> ( const _string< _malloc, _delete > &  lhs,
const _string< _malloc, _delete > &  rhs 
)
friend

◆ operator>=

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
bool operator>= ( const _string< _malloc, _delete > &  lhs,
const _string< _malloc, _delete > &  rhs 
)
friend

类成员变量说明

◆ _increaseBy

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_increaseBy = container_increase_step::value
private

◆ _str

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
char* nstd::_string< _malloc, _delete >::_str
private

◆ _str_cap

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_str_cap
private

◆ _str_len

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
std::size_t nstd::_string< _malloc, _delete >::_str_len
private

◆ delete_fun_

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
element_delete_fun_t<char> nstd::_string< _malloc, _delete >::delete_fun_
private

◆ malloc_fun_

template<element_malloc_fun_t< char > _malloc = memory::safe_malloc_container_element<char>, element_delete_fun_t< char > _delete = memory::safe_delete_container_element<char>>
element_malloc_fun_t<char> nstd::_string< _malloc, _delete >::malloc_fun_
private
该类的文档由以下文件生成: