SGI

basic_string<charT, traits, Alloc>

类别: 容器 组件类型: 类型

描述

该basic_string类表示一个 字符序列。 它包含 序列 的所有常用操作，此外，它还包含标准字符串操作，例如搜索和串联。

该basic_string类由字符类型参数化，以及该类型的 字符特征。 但是，大多数情况下，不需要直接使用basic_string模板。 类型string和wstring分别是basic_string<char>和basic_string<wchar_t>.

的类型定义。basic_string中的一些成员函数使用了一种不寻常的方法来指定位置和范围。 除了使用迭代器的传统方法之外，许多basic_string的成员函数使用一个单一的值pos类型为size_type来表示一个位置（在这种情况下，位置为begin() + pos），并且许多basic_string的成员函数使用两个值，pos和n和posposn来表示一个范围。 在这种情况下，pos.

是范围的起点，而basic_stringnbasic_string是其大小。 也就是说，该范围为[begin() + pos, begin() + pos + n)请注意，C++ 标准未指定操作的复杂度。 在此实现中，的性能特征与操作的复杂度。 在此实现中，vector

非常相似：访问单个字符为 *O(1)*，而复制和串联为 *O(N)*。 相反，basic_stringrope具有截然不同的性能特征：大多数, 操作具有对数复杂度。, 另请注意，根据 C++ 标准，具有非常不寻常的迭代器失效语义。 迭代器可能会因以下操作而失效：swapreserve另请注意，根据 C++ 标准，insertswap以及erase, （以及等效于, 和/或具有非常不寻常的迭代器失效语义。 迭代器可能会因以下操作而失效：的函数，例如clearresizeappendreplace）。 此外，对 *任何* 非 const 成员函数的第一次调用（包括非 const 版本的resize, begin(), 或, operator[], replace, ）可能会使迭代器失效。（这些迭代器失效规则的目的是为实现者在实现技术方面提供更大的自由度。）在此实现中，具有非常不寻常的迭代器失效语义。 迭代器可能会因以下操作而失效：end()rbegin()

rend()

int main() { 
  string s(10u, ' ');           // Create a string of ten blanks.

  const char* A = "this is a test";
  s += A;
  cout << "s = " << (s + '\n');
  cout << "As a null-terminated sequence: " << s.c_str() << endl;
  cout << "The sixteenth character is " << s[15] << endl;
  
  reverse(s.begin(), s.end());
  s.push_back('\n');
  cout << s;
}

c_str()

data()

不会使迭代器失效。 在此实现中，迭代器仅会被明确更改字符串内容的成员函数使失效。

示例 描述 定义
在标准头文件 string 中定义。 模板参数  
参数 默认值 charT
字符串的值类型：它包含的字符类型。 traits 字符特征 类型，它封装了基本字符操作。

char_traits<charT>

Alloc

字符串的分配器，用于内部内存管理。

alloc

类型要求

除了 随机访问容器 和 序列 强加的类型要求之外，

是 POD（“普通数据”）类型。

是 字符特征 类型，其值类型为 charT 描述
公共基类 无。 成员成员定义位置
value_type 无。 容器成员.
对象类型， 无。 charT成员
，存储在字符串中。 无。 pointer成员
size_type 无。 指向
charT 无。 的指针。
reference basic_string 指向size_typecharT的引用。.
const_reference 无。 指向basic_stringcharT
的常量引用。 无。 size_type
无符号整型。 difference_type 有符号整型。
static const size_type npos difference_type 类型
size_type 无。 的最大可能值。 也就是说，const_referencesize_type(-1)
iterator 无。 的最大可能值。 也就是说，const_reference用于遍历字符串的迭代器。 一个
basic_string 无。 提供 随机访问迭代器。的常量引用。size_type(-1)
const_iterator 无。 提供 随机访问迭代器。的常量引用。用于遍历字符串的迭代器。 一个
用于遍历字符串的常量迭代器。 difference_type 提供 随机访问迭代器。无符号整型。reverse_iterator
可逆容器 difference_type 提供 随机访问迭代器。无符号整型。用于反向遍历字符串的迭代器。
const_reverse_iterator difference_type 提供 随机访问迭代器。static const size_type nposreverse_iterator
用于反向遍历字符串的常量迭代器。 difference_type 提供 随机访问迭代器。static const size_type npos用于反向遍历字符串的迭代器。
iterator begin() 无。 返回一个指向字符串开头的
iterator basic_string 。iterator end().
返回一个指向字符串结尾的 无。 iterator
。 basic_string const_iterator begin() const
返回一个指向字符串开头的 无。 const_iterator。0.
const_iterator end() const 返回一个指向字符串结尾的 const_iteratorn。
reverse_iterator rbegin() 返回一个指向字符串结尾的 const_iteratorn。
返回一个指向反转字符串开头的 basic_string reverse_iterator
。 basic_string reverse_iterator rend()
返回一个指向反转字符串结尾的 无。 reverse_iterator 
basic_string(const basic_string& s, 
             size_type pos = 0, size_type n = npos)
无。, basic_string 。
const_reverse_iterator rbegin() const basic_string 返回一个指向反转字符串开头的
const_reverse_iterator basic_string 。
const_reverse_iterator rend() const 返回一个指向反转字符串结尾的 const_reverse_iteratorn。size_type size() const. 
template <class InputIterator>
basic_string(InputIterator first, InputIterator last)
返回一个指向反转字符串结尾的 返回字符串的大小。
size_type length() const 无。 是
size() 无。 的同义词。
size_type max_size() const basic_string 返回字符串的最大可能大小。
size_type capacity() const basic_string 见下文。
bool empty() const basic_string const_iterator begin() const
如果字符串的大小为 无。 0 
iterator insert(iterator pos,
                const T& x)
返回一个指向反转字符串结尾的 ，则返回true。pos. 
template <class InputIterator>
void insert(iterator pos,
            InputIterator f, InputIterator l)
[1]
返回一个指向反转字符串结尾的 reference operator[](size_type n)随机访问容器。pos. 
void insert(iterator pos, 
            size_type n, const T& x)
返回一个指向反转字符串结尾的 ，则返回n。true。pos.
返回第 basic_string ，则返回n。pos. 
basic_string& insert(size_type pos, 
                     const basic_string& s, 
                     size_type pos1, size_type n)
basic_string 个字符。n。pos.
const_reference operator[](size_type n) const basic_string ，则返回n。pos.
const charT* c_str() const basic_string 返回指向表示字符串内容的以空字符结尾的字符数组的指针。n。pos.
const charT* data() const basic_string ，则返回n。size_type size() const。pos.
返回指向表示字符串内容的字符数组（不一定是以空字符结尾）的指针。 basic_string basic_string()n创建一个空字符串。复制构造函数的泛化。. 
basic_string& append(const basic_string& s, 
                     size_type pos, size_type n)
basic_string basic_string(const charT*)n创建一个空字符串。复制构造函数的泛化。.
从以空字符结尾的字符数组构造一个字符串。 basic_string basic_string()n创建一个空字符串。复制构造函数的泛化。.
basic_string(const charT* s, size_type n) basic_string 从字符数组和长度构造一个字符串。nbasic_string(size_type n, charT c)n创建一个空字符串。复制构造函数的泛化。.
序列 basic_string basic_string()n。size_type size() const创建一个空字符串。复制构造函数的泛化。. 
template <class InputIterator>
basic_string& append(InputIterator first, InputIterator last)
basic_string 创建一个包含复制构造函数的泛化。.
n basic_string 个复制构造函数的泛化。.
c basic_string 副本的字符串。basic_string(const basic_string&).
basic_string(const basic_string&, size_type, size_type) basic_string 副本的字符串。basic_string(const basic_string&)
basic_string(const basic_string&, size_type, size_type, Alloc) basic_string 副本的字符串。basic_string(const basic_string&, Alloc)
basic_string(const charT*, Alloc) 返回一个指向反转字符串结尾的 basic_string(const charT*, size_type, Alloc)basic_string(const charT*, size_type, size_type, Alloc)
basic_string(initializer_list<charT>, Alloc) 返回一个指向反转字符串结尾的 basic_string(initializer_list<charT>)随机访问容器
basic_string(const basic_string&, size_type, size_type) basic_string basic_string(const charT*, size_type)
basic_string(const charT*, size_type, size_type) 返回一个指向反转字符串结尾的 basic_string(const basic_string&, Alloc)
basic_string(const charT*, Alloc) 返回一个指向反转字符串结尾的 basic_string(const charT*, size_type, Alloc)nbasic_string(const charT*, size_type, size_type, Alloc)
basic_string(initializer_list<charT>, Alloc) basic_string 。basic_string(initializer_list<charT>) 
 
basic_string& assign(const basic_string& s, 
                     size_type pos, size_type n)
basic_string 从范围创建一个字符串。n创建一个空字符串。复制构造函数的泛化。
~basic_string() basic_string 析构函数。nbasic_string(size_type n, charT c)n创建一个空字符串。复制构造函数的泛化。.
basic_string& operator=(const basic_string&) basic_string 赋值运算符复制构造函数的泛化。.
basic_string& operator=(const charT* s) 返回一个指向反转字符串结尾的 将以空字符结尾的字符数组分配给字符串。n。size_type size() const. 
template <class InputIterator>
basic_string& assign(InputIterator first, InputIterator last)
返回一个指向反转字符串结尾的 将以空字符结尾的字符数组分配给字符串。随机访问容器 
basic_string& replace(size_type pos, size_type n, 
                      const basic_string& s)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。将单个字符分配给字符串。n. 
basic_string& replace(size_type pos, size_type n, 
                      const basic_string& s, 
                      size_type pos1, size_type n1)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。basic_string& operator=(initializer_list<charT>)n. 
basic_string& replace(size_type pos, size_type n, 
                      const charT* s, size_type n1)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。void reserve(size_t)void swap(basic_string&)basic_string(size_type n, charT c)n. 
basic_string& replace(size_type pos, size_type n, 
                      const charT* s)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。交换两个字符串的内容。 
basic_string& replace(size_type pos, size_type n, 
                      size_type n1, charT c)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。插入void swap(basic_string&)。size_type size() const. 
basic_string& replace(iterator first, iterator last, 
                      const basic_string& s)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。将单个字符分配给字符串。n. 
basic_string& replace(iterator first, iterator last, 
                      const charT* s, size_type n)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。void reserve(size_t)nbasic_string(size_type n, charT c)n. 
basic_string& replace(iterator first, iterator last, 
                      const charT* s)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。交换两个字符串的内容。 
basic_string& replace(iterator first, iterator last, 
                      size_type n, charT c)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。插入n。size_type size() const. 
template <class InputIterator>
basic_string& replace(iterator first, iterator last, 
                      InputIterator f, InputIterator l)
basic_string basic_string& operator=(charT c)复制构造函数的泛化。x在
pos basic_string 之前。复制构造函数的泛化。插入范围
[first, last) basic_string basic_string& insert(size_type pos, const basic_string& s)ns复制构造函数的泛化。插入poss复制构造函数的泛化。.
的子字符串。 basic_string basic_string& insert(size_type pos, const charT* s)nbasic_string(size_type n, charT c)ns复制构造函数的泛化。插入poss复制构造函数的泛化。.
basic_string& insert(size_type pos, const charT* s, size_type n) basic_string 插入复制构造函数的泛化。插入poss复制构造函数的泛化。.
s basic_string 的前size_type size() constnpos.
个字符。 basic_string basic_string& insert(size_type pos, size_type n, charT c)ns复制构造函数的泛化。nbasic_string& append(const basic_string& s)
追加 basic_string snbasic_string(size_type n, charT c)ns复制构造函数的泛化。nbasic_string& append(const basic_string& s)
到 basic_string *this复制构造函数的泛化。插入basic_string& append(const basic_string& s)
。 basic_string 追加size_type size() constns.
的子字符串。 basic_string basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos追加n.
s basic_string basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos的前nbasic_string(size_type n, charT c)n.
n basic_string basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos追加n.
个字符。 basic_string basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)posbasic_string& append(size_type n, charT c)size_type size() const.
追加范围到 basic_string basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos*thisn.
。 basic_string basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)posvoid push_back(charT c)nbasic_string(size_type n, charT c)n.
追加单个字符到 basic_string basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos*thisn.
*this basic_string basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos。size_type size() const.
basic_string& operator+=(const basic_string& s) basic_string 等效于复制构造函数的泛化。basic_string& append(const charT* s, size_type n)basic_string& append(const basic_string& s)追加n.
append(s) basic_string 等效于复制构造函数的泛化。basic_string& append(const charT* s, size_type n)basic_string& append(const basic_string& s)的前nbasic_string(size_type n, charT c)n.
。 basic_string basic_string& operator+=(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)basic_string& append(const basic_string& s)追加n.
basic_string& operator+=(charT c) basic_string basic_string& operator+=(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)basic_string& append(const basic_string& s)basic_string& append(size_type n, charT c)size_type size() const.
push_back(c) basic_string 等效于复制构造函数的泛化。basic_string& append(const charT* s, size_type n)basic_string& append(const basic_string& s)*thisn.
size_type find_last_not_of(const charT* s, size_type pos, size_type n) const basic_string 等效于复制构造函数的泛化。basic_string& append(const charT* s, size_type n)basic_string& append(const basic_string& s)void push_back(charT c)nbasic_string(size_type n, charT c)n.
size_type find_last_not_of(const charT* s, size_type pos = npos) const basic_string basic_string& operator+=(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)basic_string& append(const basic_string& s)*thisn.
size_type find_last_not_of(charT c, size_type pos = npos) const basic_string basic_string& operator+=(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)basic_string& append(const basic_string& s)。size_type size() const.
basic_string substr(size_type pos = 0, size_type n = npos) const basic_string 返回的子字符串复制构造函数的泛化。.
int compare(const basic_string& s) const basic_string 三个方向的词法比较n和复制构造函数的泛化。.
int compare(size_type pos, size_type n, const basic_string& s) const basic_string 三个方向的词法比较n和子字符串复制构造函数的泛化。.
int compare(size_type pos, size_type n, const basic_string& s, size_type pos1, size_type n1) const basic_string 三个方向的词法比较子字符串n和子字符串复制构造函数的泛化。.
int compare(const charT* s) const basic_string 三个方向的词法比较n和复制构造函数的泛化。.
int compare(size_type pos, size_type n, const charT* s, size_type len = npos) const basic_string 三个方向的词法比较第一个min(len, traits::length(s)basic_string(size_type n, charT c)n和子字符串复制构造函数的泛化。. 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)
basic_string 字符串连接。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const charT* s1,
          const basic_string<charT, traits, Alloc>& s2)
basic_string 字符串连接。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const charT* s2)
basic_string 字符串连接。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(charT c,
          const basic_string<charT, traits, Alloc>& s2)
basic_string 字符串连接。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          charT c)
basic_string 字符串连接。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator==(const basic_string<charT, traits, Alloc>& s1,
                const basic_string<charT, traits, Alloc>& s2)
无。 字符串相等。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator==(const charT* s1, 
                const basic_string<charT, traits, Alloc>& s2)
basic_string 字符串相等。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator==(const basic_string<charT, traits, Alloc>& s1,
                const charT* s2)
basic_string 字符串相等。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator!=(const basic_string<charT, traits, Alloc>& s1,
                const basic_string<charT, traits, Alloc>& s2)
无。 字符串不相等。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator!=(const charT* s1, 
                const basic_string<charT, traits, Alloc>& s2)
basic_string 字符串不相等。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator!=(const basic_string<charT, traits, Alloc>& s1,
                const charT* s2)
basic_string 字符串不相等。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator<(const basic_string<charT, traits, Alloc>& s1,
               const basic_string<charT, traits, Alloc>& s2)
无。 字符串比较。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator<(const charT* s1, 
               const basic_string<charT, traits, Alloc>& s2)
basic_string 字符串比较。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
bool operator<(const basic_string<charT, traits, Alloc>& s1,
               const charT* s2)
basic_string 字符串比较。全局函数，不是成员函数。 
template <class charT, class traits, class Alloc>
void swap(basic_string<charT, traits, Alloc>& s1,
          basic_string<charT, traits, Alloc>& s2)
无。 0 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
           basic_string<charT, traits, Alloc>& s)
basic_string 读取n从输入流是 
template <class charT, class traits, class Alloc>
basic_ostream<charT, traits>&
operator<<(basic_istream<charT, traits>& os,
           const basic_string<charT, traits, Alloc>& s)
basic_string 写入n到输出流os 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Alloc>& s,
        charT delim)
basic_string 从输入流读取字符串是，当它到达时停止delim 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Alloc>& s)
basic_string 从输入流读取单行是

新成员

这些成员没有在 随机访问容器 和 序列 中定义：要求，而是特定于basic_string.
是 字符特征 类型，其值类型为 描述
reference 指向size_typecharT的引用。.
iterator 副本的字符串。iterator end().
。 已分配内存的元素数量。也就是说，字符串在必须重新分配内存之前可以增长的尺寸。capacity()始终大于或等于iterator end().
返回一个指向反转字符串开头的 返回指向表示字符串内容的以空字符结尾的字符数组的指针。对于任何字符串n保证第一个s.size()由s.c_str()指向的数组中的字符等于n中的字符，并且s.c_str()[s.size()]是一个空字符。但是，请注意，它不一定是第一个空字符。字符串内的字符允许为空。
。 返回指向表示字符串内容的字符数组的指针，该数组不一定以空字符结尾。end()允许，但不要求，与）可能会使迭代器失效。（这些迭代器失效规则的目的是为实现者在实现技术方面提供更大的自由度。）在此实现中，相同。该数组的第一个iterator end()个字符保证与复制构造函数的泛化。中的字符相同。返回值end()永远不是空指针，即使iterator end()为零。
basic_string(const basic_string& s, size_type pos = 0, size_type n = npos) 从n的子字符串构造字符串。子字符串从字符位置pos开始，在字符位置pos + n或在n的末尾处终止，以先发生者为准。此构造函数抛出out_of_range如果pos > s.size()。请注意，当pos和n具有其默认值时，这只是一个复制构造函数。
basic_string(const charT* s) 副本的字符串。basic_string(s, s + traits::length(s)).
const_reverse_iterator 副本的字符串。basic_string(s, s + n).
size_type max_size() const 副本的字符串。operator=(basic_string(s)).
size_type capacity() const 分配给复制构造函数的泛化。一个大小为1且内容为单个字符size_type size() const.
void reserve(size_t n) 请求更改字符串的容量；此成员函数的后置条件是，在调用它之后，capacity() >= n。您可以通过调用reserve()并使用小于当前容量的参数来请求字符串减小其容量。（但是，如果您使用小于字符串大小的参数调用reserve()，则容量将仅减少到iterator end()。字符串的大小永远不能大于其容量。）reserve()抛出length_error如果n > max_size().
返回第 如果pos > size()，则抛出out_of_range。否则，等效于insert(begin() + pos, s.begin(), s.end()). 
basic_string& insert(size_type pos, 
                     const basic_string& s, 
                     size_type pos1, size_type n)
如果pos > size()appendpos1 > s.size()，则抛出out_of_range。否则，等效于insert(begin() + pos, s.begin() + pos1, s.begin() + pos1 + min(n, s.size() - pos1)).
const_reference operator[](size_type n) const 如果pos > size()，则抛出out_of_range。否则，等效于insert(begin() + pos, s, s + traits::length(s))
const charT* c_str() const 如果pos > size()，则抛出out_of_range。否则，等效于insert(begin() + pos, s, s + n).
const charT* data() const 如果pos > size()，则抛出out_of_range。否则，等效于insert(begin() + pos, n, c).
返回指向表示字符串内容的字符数组（不一定是以空字符结尾）的指针。 副本的字符串。insert(end(), s.begin(), s.end()). 
basic_string& append(const basic_string& s, 
                     size_type pos, size_type n)
如果pos > s.size()，则抛出out_of_range。否则，等效于insert(end(), s.begin() + pos, s.begin() + pos + min(n, s.size() - pos)).
从以空字符结尾的字符数组构造一个字符串。 副本的字符串。insert(end(), s, s + traits::length(s)).
basic_string(const charT* s, size_type n) 副本的字符串。insert(end(), s, s + n).
序列 副本的字符串。insert(end(), n, c). 
template <class InputIterator>
basic_string& append(InputIterator first, InputIterator last)
副本的字符串。insert(end(), first, last).
n 副本的字符串。insert(end(), c)
c 副本的字符串。basic_string(const basic_string&).
basic_string(const basic_string&, size_type, size_type) 副本的字符串。basic_string(const basic_string&)
basic_string(const basic_string&, size_type, size_type, Alloc) 副本的字符串。basic_string(const basic_string&, Alloc)
basic_string(const basic_string&, size_type, size_type) 如果pos > size()，则抛出out_of_range。否则，等效于erase(begin() + pos, begin() + pos + min(n, size() - pos)).
basic_string& assign(const basic_string& s) 。basic_string(initializer_list<charT>) 
basic_string& assign(const basic_string& s, 
                     size_type pos, size_type n)
等效于（但可能比clear()后面跟着insert(0, s, pos, n).
~basic_string() 等效于（但可能比clear()后面跟着insert(0, s, n).
basic_string& operator=(const basic_string&) 等效于（但可能比clear()后面跟着insert(0, s). 
basic_string& replace(size_type pos, size_type n, 
                      const basic_string& s)
副本的字符串。erase(pos, n)后面跟着insert(pos, s). 
basic_string& replace(size_type pos, size_type n, 
                      const basic_string& s, size_type pos1, size_type n1)
副本的字符串。erase(pos, n)后面跟着insert(pos, s, pos1, n1). 
basic_string& replace(size_type pos, size_type n, 
                      const charT* s, size_type n1)
副本的字符串。erase(pos, n)后面跟着insert(pos, s, n1). 
basic_string& replace(size_type pos, size_type n, 
                      const charT* s)
副本的字符串。erase(pos, n)后面跟着insert(pos, s). 
basic_string& replace(size_type pos, size_type n, 
                      size_type n1, charT c)
副本的字符串。erase(pos, n)后面跟着insert(pos, n1, c). 
basic_string& replace(iterator first, iterator last, 
                      const basic_string& s)
副本的字符串。insert(erase(first, last), s.begin(), s.end()). 
basic_string& replace(iterator first, iterator last, 
                      const charT* s, size_type n)
副本的字符串。insert(erase(first, last), s, s + n). 
basic_string& replace(iterator first, iterator last, 
                      const charT* s)
副本的字符串。insert(erase(first, last), s, s + traits::length(s)). 
basic_string& replace(iterator first, iterator last, 
                      size_type n, charT c)
副本的字符串。insert(erase(first, last), n, c). 
template <class InputIterator>
basic_string& replace(iterator first, iterator last, 
                      InputIterator f, InputIterator l)
副本的字符串。insert(erase(first, last), f, l).
pos 最多复制n个字符从复制构造函数的泛化。到字符数组。抛出out_of_range如果pos > size()。否则，等效于copy(begin() + pos, begin() + pos + min(n, size()), buf)。请注意，此成员函数除了从复制构造函数的泛化。创建一个空字符串。buf复制字符之外什么也不做；特别是，它不会用空字符终止buf。
[first, last) basic_string& insert(size_type pos, const basic_string& s)ns复制构造函数的泛化。npos。它几乎与search相同，只是search使用operator==或用户提供的函数对象测试元素是否相等，而此成员函数使用traits::eq。返回最低的字符位置N，使得pos <= N和pos + s.size() <= size()，并且使得对于每个i小于s.size(), (*this)[N + i]与s[i]进行比较相等。返回npos如果没有这样的位置N存在。请注意，用这样的参数调用此成员函数是合法的s.size() > size() - pos，但这样的搜索总是会失败。
的子字符串。 basic_string& insert(size_type pos, const charT* s)nbasic_string(size_type n, charT c)ns复制构造函数的泛化。插入poss复制构造函数的泛化。。这等效于find(basic_string(s, n), pos).
basic_string& insert(size_type pos, const charT* s, size_type n) 插入复制构造函数的泛化。插入poss复制构造函数的泛化。。这等效于find(basic_string(s), pos).
s 的前size_type size() constnpos。也就是说，返回第一个字符位置N大于或等于pos，并且小于iterator end()，使得(*this)[N]与size_type size() const进行比较相等。返回npos如果没有这样的字符位置N存在。
个字符。 basic_string& insert(size_type pos, size_type n, charT c)ns复制构造函数的泛化。。它几乎与find_end相同，只是find_end使用operator==或用户提供的函数对象测试元素是否相等，而此成员函数使用traits::eq。此成员函数返回最大的字符位置N，使得N <= pos和N + s.size() <= size()，并且使得对于每个i小于s.size(), (*this)[N + i]与s[i]进行比较相等。返回npos如果没有这样的位置N存在。请注意，用这样的参数调用此成员函数是合法的s.size() > size()，但这样的搜索总是会失败。
追加 snbasic_string(size_type n, charT c)ns复制构造函数的泛化。。等效于rfind(basic_string(s, n), pos).
到 *this复制构造函数的泛化。。等效于rfind(basic_string(s), pos).
。 追加size_type size() const。也就是说，返回最大的字符位置N，使得N <= pos和N < size()，并且使得(*this)[N]与size_type size() const进行比较相等。返回npos如果没有这样的字符位置存在。
的子字符串。 basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos追加n。这类似于标准算法find_first_of，但不同之处在于find_first_of使用operator==或用户提供的函数对象测试元素是否相等，而此成员函数使用traits::eq比较字符。返回最小的字符位置N，使得pos <= N < size()，并且使得(*this)[N]与n进行比较相等。返回npos如果没有这样的字符位置存在。
s basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos中的某个字符进行比较相等，对于第一个与范围内的任何字符相等的字符[s, s+n)。也就是说，返回最小的字符位置N，使得pos <= N < size()，并且使得(*this)[N]与[s, s+n)进行比较相等。返回npos如果没有这样的字符位置存在。
n 副本的字符串。中的某个字符进行比较相等.
个字符。 副本的字符串。find_first_of(s, pos, traits::length(s)).
追加范围到 basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos*thisn比较字符。返回最小的字符位置N，使得pos <= N < size()，并且使得(*this)[N]find(c, pos)n进行比较相等。返回npos如果没有这样的字符位置存在。
。 basic_string& append(const charT* s)复制构造函数的泛化。basic_string& append(const charT* s, size_type n)pos与[s, s+n)。也就是说，返回最小的字符位置N，使得pos <= N < size()，并且使得(*this)[N]中的任何字符进行比较都不相等，对于第一个与范围内的任何字符都不相等的字符[s, s+n)进行比较相等。返回npos如果没有这样的字符位置存在。
追加单个字符到 副本的字符串。find_first_not_of(s, pos, traits::length(s)).
*this 返回最小的字符位置N，使得pos <= N < size()，并且使得(*this)[N]与size_type size() const进行比较相等。返回npos如果没有这样的字符位置存在。
basic_string& operator+=(const basic_string& s) 等效于复制构造函数的泛化。进行比较不相等，对于第一个与n。也就是说，返回最大的字符位置N，使得N <= pos和N < size()，并且使得(*this)[N]与n进行比较相等。返回npos如果没有这样的字符位置存在。
append(s) 等效于复制构造函数的泛化。中的任何字符进行比较相等的字符[s, s+n)。也就是说，返回最大的字符位置N，使得N <= pos和N < size()，并且使得(*this)[N]与[s, s+n)进行比较相等。返回npos如果没有这样的字符位置存在。
。 副本的字符串。find_last_of(s, pos, traits::length(s)).
basic_string& operator+=(charT c) 副本的字符串。rfind(c, pos).
push_back(c) 等效于复制构造函数的泛化。对于第一个与n。也就是说，返回最大的字符位置N，使得N <= pos和N < size()，并且使得(*this)[N]find(c, pos)n进行比较相等。返回npos如果没有这样的字符位置存在。
size_type find_last_not_of(const charT* s, size_type pos, size_type n) const 等效于复制构造函数的泛化。对于第一个与[s, s+n)。也就是说，返回最大的字符位置N，使得N <= pos和N < size()，并且使得(*this)[N]find(c, pos)[s, s+n)进行比较相等。返回npos如果没有这样的字符位置存在。
size_type find_last_not_of(const charT* s, size_type pos = npos) const 副本的字符串。find_last_of(s, pos, traits::length(s)).
size_type find_last_not_of(charT c, size_type pos = npos) const basic_string& operator+=(const charT* s)复制构造函数的泛化。进行比较不相等的字符size_type size() const。也就是说，返回最大的字符位置N，使得N <= pos和N < size()，并且使得(*this)[N]与size_type size() const.
basic_string substr(size_type pos = 0, size_type n = npos) const 副本的字符串。basic_string(*this, pos, n).
int compare(const basic_string& s) const 三个方向的词法比较n和复制构造函数的泛化。，非常类似于strcmp。如果traits::compare(data, s.data(), min(size(), s.size()))不为零，则它返回该非零值。否则，如果size() < s.size()，则返回负数，如果size() > s.size()，则返回正数，如果两者相等，则返回零。
int compare(size_type pos, size_type n, const basic_string& s) const 三个方向的词法比较n和子字符串复制构造函数的泛化。。等效于basic_string(*this, pos, n).compare(s).
int compare(size_type pos, size_type n, const basic_string& s, size_type pos1, size_type n1) const 三个方向的词法比较子字符串n和子字符串复制构造函数的泛化。。等效于basic_string(*this, pos, n).compare(basic_string(s, pos1, n1)).
int compare(const charT* s) const 三个方向的词法比较n和复制构造函数的泛化。。等效于compare(basic_string(s)).
int compare(size_type pos, size_type n, const charT* s, size_type len = npos) const 三个方向的词法比较第一个min(len, traits::length(s)basic_string(size_type n, charT c)n和子字符串复制构造函数的泛化。。等效于basic_string(*this, pos, n).compare(basic_string(s, min(len, traits::length(s)))). 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)
字符串连接。等效于创建n的临时副本，追加s2，然后返回临时副本。 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const charT* s1,
          const basic_string<charT, traits, Alloc>& s2)
字符串连接。等效于从basic_strings1创建临时对象，然后返回临时对象。的临时副本，追加s2字符串连接。等效于使用构造函数创建临时对象 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const charT* s2)
字符串连接。等效于创建n的临时副本，追加s2，然后返回临时副本。 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(charT c,
          const basic_string<charT, traits, Alloc>& s2)
basic_string(1, c)字符串连接。等效于创建临时对象，追加的临时副本，追加s2字符串连接。等效于使用构造函数创建临时对象 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          charT c)
push_backsize_type size() const插入字符串相等。等效于字符串连接。等效于使用构造函数创建临时对象 
template <class charT, class traits, class Alloc>
bool operator==(const charT* s1, 
                const basic_string<charT, traits, Alloc>& s2)
basic_string(s1).compare(s2) == 0字符串不相等。等效于. 
template <class charT, class traits, class Alloc>
bool operator==(const basic_string<charT, traits, Alloc>& s1,
                const charT* s2)
basic_string(s1).compare(s2) == 0字符串不相等。等效于. 
template <class charT, class traits, class Alloc>
bool operator!=(const charT* s1, 
                const basic_string<charT, traits, Alloc>& s2)
!(s1 == s2)字符串不相等。等效于. 
template <class charT, class traits, class Alloc>
bool operator!=(const basic_string<charT, traits, Alloc>& s1,
                const charT* s2)
!(s1 == s2)字符串比较。等效于. 
template <class charT, class traits, class Alloc>
bool operator<(const charT* s1, 
               const basic_string<charT, traits, Alloc>& s2)
。具体来说，它跳过空格，然后用从输入流读取的字符替换字符串比较。等效于. 
template <class charT, class traits, class Alloc>
bool operator<(const basic_string<charT, traits, Alloc>& s1,
               const charT* s2)
。具体来说，它跳过空格，然后用从输入流读取的字符替换字符串比较。等效于. 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
           basic_string<charT, traits, Alloc>& s)
读取n从输入流是的内容。它继续读取字符，直到遇到空格字符（在这种情况下，该字符不会被提取），或者直到文件结束，或者，如果nis.width()不为零，直到它读取了个字符。此成员函数将不为零，直到它读取了重置为零。不为零，直到它读取了。它写入 
template <class charT, class traits, class Alloc>
basic_ostream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
           const basic_string<charT, traits, Alloc>& s)
写入n到输出流是max(s.size(), is.width())个字符，根据需要进行填充。此成员函数将重置不为零，直到它读取了。它写入 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Alloc>& s,
        charT delim)
用从输入流读取的字符替换n的内容。它继续读取字符，直到遇到字符delim（在这种情况下，该字符会被提取，但不会存储在n中），或者直到文件结束。请注意，getline，与operator>>不同，不会跳过空格。顾名思义，它最常用于读取与输入文件中显示的完全相同的整行文本。 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Alloc>& s)
副本的字符串。getline(is, s, is.widen('\n\)).

注意

另请参见

操作的复杂度。 在此实现中，, [begin() + pos, begin() + pos + n)，字符特征
[Silicon Surf] [STL Home]
Copyright © 1999 Silicon Graphics, Inc. 保留所有权利。 商标信息