Iterators

 Capacity

resize

void resize (size_t n);void resize (size_t n, char c);

Resize string

将字符串的大小调整为n个字符的长度。 如果n小于当前字符串长度，则当前值将缩短为其第一个n字符，删除第n个字符之后的字符。 如果n大于当前字符串长度，则通过在末尾插入所需数量的字符以达到n的大小来扩展当前内容。如果指定了c，则将新元素初始化为c的副本，否则，它们是值初始化字符（null字符）。

reserve

void reserve (size_t n = 0);

Request a change in capacity

请求字符串容量适应计划中的大小更改，最大长度为n个字符。 如果n大于当前字符串容量，则函数会使容器的容量增加到n个字符（或更多）。 在所有其他情况下，它被视为收缩字符串容量的非绑定请求：容器实现可以自由地进行其他优化，并使字符串的容量大于n。 此函数对字符串长度没有影响，也不能更改其内容。

shrink_to_fit

void shrink_to_fit();

Shrink to fit

请求字符串减小其容量以适应其大小。 该请求是非绑定的，容器实现可以自由地进行其他优化，并使字符串的容量大于其大小。 此函数对字符串长度没有影响，也不能更改其内容。

Element access

 Modifiers

 operator+=

string& operator+= (const string& str);

string& operator+= (const char* s);

string& operator+= (char c);

string& operator+= (initializer_list<char> il);

附加到字符串 通过在字符串当前值的末尾附加附加字符来扩展字符串：

// string::operator+=
#include <iostream>
#include <string>int main ()
{std::string name ("John");std::string family ("Smith");name += " K. ";         // c-stringname += family;         // stringname += '\n';           // characterstd::cout << name;return 0;
}Output:

John K. Smith

append

string& append (const string& str);

string& append (const string& str, size_t subpos, size_t sublen = npos);

string& append (const char* s);

string& append (const char* s, size_t n);

string& append (size_t n, char c);

template <class InputIterator>   string& append (InputIterator first, InputIterator last);

string& append (initializer_list<char> il);

附加到字符串

通过在字符串当前值的末尾附加附加字符来扩展字符串：

（1） string

附加str的副本。

（2）  substring

附加str的子字符串的副本。子字符串是str的一部分，从字符位置subbase开始，跨越子字符串（或者直到str的末尾，如果str太短或子字符串为string:：npos）。

（3）  c-string

附加由s指向的以null结尾的字符序列（C字符串）形成的字符串的副本。

（4） buffer

追加s指向的字符数组中前n个字符的副本。

（5） fill

追加字符c的n个连续副本。

（6） range

以相同的顺序追加范围[第一个，最后一个）中的字符序列的副本。

（7）  initializer list

以相同的顺序追加il中每个字符的副本。

// appending to string
#include <iostream>
#include <string>int main ()
{std::string str;std::string str2="Writing ";std::string str3="print 10 and then 5 more";// used in the same order as described above:str.append(str2);                       // "Writing "str.append(str3,6,3);                   // "10 "str.append("dots are cool",5);          // "dots "str.append("here: ");                   // "here: "str.append(10u,'.');                    // ".........."str.append(str3.begin()+8,str3.end());  // " and then 5 more"str.append<int>(5,0x2E);                // "....."std::cout << str << '\n';return 0;
}Output:

Writing 10 dots here: .......... and then 5 more.....

push_back

void push_back (char c);

将字符附加到字符串 将字符c追加到字符串的末尾，使其长度增加一。

// string::push_back
#include <iostream>
#include <fstream>
#include <string>int main ()
{std::string str;std::ifstream file ("test.txt",std::ios::in);if (file) {while (!file.eof()) str.push_back(file.get());}std::cout << str << '\n';return 0;
}This example reads an entire file character by character, appending each character to a string object using push_back.

assign

string& assign (const string& str);

string& assign (const string& str, size_t subpos, size_t sublen = npos);

string& assign (const char* s);

string& assign (const char* s, size_t n);

string& assign (size_t n, char c);

template <class InputIterator>   string& assign (InputIterator first, InputIterator last);

string& assign (initializer_list<char> il);

string& assign (string&& str) noexcept;

将内容分配给字符串

为字符串指定一个新值，替换其当前内容。

（1） string

复制str。

（2）  substring

复制str中从字符位置子组开始并跨越子组字符的部分（如果str太短或子组为string:：npos，则复制到str的末尾）。

（3） c-string

复制s指向的以null结尾的字符序列（C字符串）。

（4） buffer

从s指向的字符数组中复制前n个字符。

（5） fill

用字符c的n个连续副本替换当前值。

（6） range

按相同顺序复制范围[第一个，最后一个）中的字符序列。

（7） initializer list

按照相同的顺序复制il中的每个字符。

（8）  move

获取str的内容。 str处于未指定但有效的状态。

// string::assign
#include <iostream>
#include <string>int main ()
{std::string str;std::string base="The quick brown fox jumps over a lazy dog.";// used in the same order as described above:str.assign(base);std::cout << str << '\n';str.assign(base,10,9);std::cout << str << '\n';         // "brown fox"str.assign("pangrams are cool",7);std::cout << str << '\n';         // "pangram"str.assign("c-string");std::cout << str << '\n';         // "c-string"str.assign(10,'*');std::cout << str << '\n';         // "**********"str.assign<int>(10,0x2D);std::cout << str << '\n';         // "----------"str.assign(base.begin()+16,base.end()-12);std::cout << str << '\n';         // "fox jumps over"return 0;
}Output:

The quick brown fox jumps over a lazy dog.
brown fox
pangram
c-string
**********
----------
fox jumps over

insert

 string& insert (size_t pos, const string& str);

 string& insert (size_t pos, const string& str, size_t subpos, size_t sublen = npos);

 string& insert (size_t pos, const char* s);

 string& insert (size_t pos, const char* s, size_t n);

 string& insert (size_t pos,   size_t n, char c);iterator insert (const_iterator p, size_t n, char c);

iterator insert (const_iterator p, char c);

template <class InputIterator>iterator insert (iterator p, InputIterator first, InputIterator last);

 string& insert (const_iterator p, initializer_list<char> il);

插入字符串

在由pos（或p）表示的字符之前的字符串中插入其他字符：

（1）string

插入str的副本。

（2）substring

插入str的子字符串的副本。该子字符串是str的一部分，该部分从字符位置subbase开始，跨越子字符串字符（或者直到str的末尾，如果str太短或子字符串为npos）。

（3）c-string

插入由s指向的以null结尾的字符序列（C字符串）形成的字符串的副本。

（4）buffer

在由s指向的字符数组中插入前n个字符的副本。

（5）fill

插入字符c的n个连续副本。

（6）single character

插入字符c。

（7）range

以相同的顺序插入范围[第一个，最后一个）中的字符序列的副本。

（8）initializer list

按照相同的顺序插入il中每个字符的副本。 size_t是一个无符号整数类型（与成员类型string:：size_type相同）。

// inserting into a string
#include <iostream>
#include <string>int main ()
{std::string str="to be question";std::string str2="the ";std::string str3="or not to be";std::string::iterator it;// used in the same order as described above:str.insert(6,str2);                 // to be (the )questionstr.insert(6,str3,3,4);             // to be (not )the questionstr.insert(10,"that is cool",8);    // to be not (that is )the questionstr.insert(10,"to be ");            // to be not (to be )that is the questionstr.insert(15,1,':');               // to be not to be(:) that is the questionit = str.insert(str.begin()+5,','); // to be(,) not to be: that is the questionstr.insert (str.end(),3,'.');       // to be, not to be: that is the question(...)str.insert (it+2,str3.begin(),str3.begin()+3); // (or )std::cout << str << '\n';return 0;
}Output:

to be, or not to be: that is the question...

erase

 string& erase (size_t pos = 0, size_t len = npos);

iterator erase (const_iterator p);

iterator erase (const_iterator first, const_iterator last);

删除字符串中的字符

擦除字符串的一部分，缩短其长度：

（1）sequence

删除字符串值中从字符位置pos开始并跨越len个字符的部分（或者，如果内容太短或len为string:：npos，则直到字符串结束）。 请注意，默认参数会擦除字符串中的所有字符（类似于成员函数clear）。

（2）character

删除p所指的字符。

（3）range

删除范围[第一个，最后一个]中的字符序列。

// string::erase
#include <iostream>
#include <string>int main ()
{std::string str ("This is an example sentence.");std::cout << str << '\n';// "This is an example sentence."str.erase (10,8);                        //            ^^^^^^^^std::cout << str << '\n';// "This is an sentence."str.erase (str.begin()+9);               //           ^std::cout << str << '\n';// "This is a sentence."str.erase (str.begin()+5, str.end()-9);  //       ^^^^^std::cout << str << '\n';// "This sentence."return 0;
}Output:

This is an example sentence.
This is an sentence.
This is a sentence.
This sentence.

replace

string& replace (size_t pos,        size_t len,        const string& str);string& replace (const_iterator i1, const_iterator i2, const string& str);

string& replace (size_t pos,        size_t len,        const string& str,                 size_t subpos, size_t sublen = npos);

string& replace (size_t pos,        size_t len,        const char* s);string& replace (const_iterator i1, const_iterator i2, const char* s);

string& replace (size_t pos,        size_t len,        const char* s, size_t n);string& replace (const_iterator i1, const_iterator i2, const char* s, size_t n);

string& replace (size_t pos,        size_t len,        size_t n, char c);string& replace (const_iterator i1, const_iterator i2, size_t n, char c);

template <class InputIterator>  string& replace (const_iterator i1, const_iterator i2,                   InputIterator first, InputIterator last);

string& replace (const_iterator i1, const_iterator i2, initializer_list<char> il);

替换字符串的一部分

将字符串中从字符pos开始并跨越len个字符的部分（或[i1，i2）之间范围内的部分）替换为新内容：

（1）string

复制str。

（2）substring

复制str中从字符位置子组开始并跨越子组字符的部分（如果str太短或子组为string:：npos，则复制到str的末尾）。

（3）c-string

复制s指向的以null结尾的字符序列（C字符串）。

（4）buffer

从s指向的字符数组中复制前n个字符。

（5）fill

用字符c的n个连续副本替换字符串的部分。

（6）range

按相同顺序复制范围[第一个，最后一个）中的字符序列。

（7）initializer list

按照相同的顺序复制il中的每个字符。

// replacing in a string
#include <iostream>
#include <string>int main ()
{std::string base="this is a test string.";std::string str2="n example";std::string str3="sample phrase";std::string str4="useful.";// replace signatures used in the same order as described above:// Using positions:                 0123456789*123456789*12345std::string str=base;           // "this is a test string."str.replace(9,5,str2);          // "this is an example string." (1)str.replace(19,6,str3,7,6);     // "this is an example phrase." (2)str.replace(8,10,"just a");     // "this is just a phrase."     (3)str.replace(8,6,"a shorty",7);  // "this is a short phrase."    (4)str.replace(22,1,3,'!');        // "this is a short phrase!!!"  (5)// Using iterators:                                               0123456789*123456789*str.replace(str.begin(),str.end()-3,str3);                    // "sample phrase!!!"      (1)str.replace(str.begin(),str.begin()+6,"replace");             // "replace phrase!!!"     (3)str.replace(str.begin()+8,str.begin()+14,"is coolness",7);    // "replace is cool!!!"    (4)str.replace(str.begin()+12,str.end()-4,4,'o');                // "replace is cooool!!!"  (5)str.replace(str.begin()+11,str.end(),str4.begin(),str4.end());// "replace is useful."    (6)std::cout << str << '\n';return 0;
}Output:

replace is useful.

swap

void swap (string& str);

交换字符串值

通过str的内容交换容器的内容，str是另一个字符串对象。长度可能不同。 在调用该成员函数之后，该对象的值是str在调用之前的值，str的值是该对象在调用之前具有的值。 请注意，存在一个具有相同名称的非成员函数，即swap，用类似于该成员函数的优化重载该算法。

// swap strings
#include <iostream>
#include <string>main ()
{std::string buyer ("money");std::string seller ("goods");std::cout << "Before the swap, buyer has " << buyer;std::cout << " and seller has " << seller << '\n';seller.swap (buyer);std::cout << " After the swap, buyer has " << buyer;std::cout << " and seller has " << seller << '\n';return 0;
}
Output:

Before the swap, buyer has money and seller has goodsAfter the swap, buyer has goods and seller has money

pop_back

void pop_back();

删除最后一个字符 擦除字符串的最后一个字符，有效地将其长度减少一个。

// string::pop_back
#include <iostream>
#include <string>int main ()
{std::string str ("hello world!");str.pop_back();std::cout << str << '\n';return 0;
}hello world