C++ string使用方法

string是C++标准模板库中专门用于字符串处理的数据结构类型。它并不是 C++的基本数据类型，它是 C++标准模板库中的一个“类”。若要使用 string 对象，则必须包含头文件#include <string>。

1. 初始化
   常用的初始化有以下几种，带等号的是拷贝初始化，

string str1("hello world");    // hello world
string str2  = "hello world";  // hello world
string str3(str2);             // hello world
string str4 = str3;            // hello world
string str5(5,'d');            // ddddd
string str6(str2, 6);          // world，从str2的第6个字符开始到结束，拷贝到str6中
string str7(str2, 0, 5);       // hello, 从str2的第0个字符开始拷贝5个字符到str7中
char buff[] = "hello sorld";
string str8(buff, 5);          // hello, 拷贝buff的前5个字符到str8中

特殊数据结构成员
static const size_t npos = -1;

2. string 的基本操作

• 长度

size_t length() const noexcept;   // 得到字符串的长度
size_t size() const noexcept;     // 得到字符串的长度
size_t max_size() const noexcept; // 得到字符串可以达到的最大长度

• 插入
  在指定的位置后面插入一个字符串

// 在pos后面插入字符串str
string& insert (size_t pos, const string& str);             
// 在pos后面插入str的subpos处往后的sublen长度的字符串
string& insert (size_t pos, const string& str, size_t subpos, size_t sublen); 
// 在pos后面插入字符数组s
string& insert (size_t pos, const char* s);                           
// 在pos后面插入字符数组s的前n个字符
string& insert (size_t pos, const char* s, size_t n);                       
// 在pos后面插入n个字符c
string& insert (size_t pos, size_t n, char c);                            
// 在p后面插入n个字符c  
iterator insert (const_iterator p, size_t n, char c);                       
// 在p后面插入一个字符c
iterator insert (const_iterator p, char c);  
// 在p后面插入迭代器first到last之间的字符串                                
template <class InputIterator>
iterator insert (iterator p, InputIterator first, InputIterator last);    
// 在p后面插入il内的所有字符
string& insert (const_iterator p, initializer_list<char> il);                 

• 替换
  把指定的位置后指定长度的字符串替换成另一个字符串

// 把pos后面len长度的字符串替换成str
string& replace (size_t pos, size_t len, const string& str);
// 把i1和i2之间的内容替换成str
string& replace (const_iterator i1, const_iterator i2, const string& str);

// 把pos后面len长度的字符串替换成字符串str的subpos后面的sublen个长度的字符串
string& replace (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen);

// 把pos后面len长度的字符串替换成字符数组s里的所有内容
string& replace (size_t pos, size_t len, const char* s);
// 把i1和i2之间的字符串替换成数组s里的所有内容
string& replace (const_iterator i1, const_iterator i2, const char* s);

// 把pos后面len长度的字符串替换成字符数组s里面前n个字符
string& replace (size_t pos, size_t len, const char* s, size_t n);
// 把i1和i2之间的字符串替换成字符数组s里面的前n个字符
string& replace (const_iterator i1, const_iterator i2, const char* s, size_t n);

// 把pos后面len长度的字符串替换成n个字符c
string& replace (size_t pos, size_t len, size_t n, char c);
// 把i1和i2之间的字符串替换成n个字符c
string& replace (const_iterator i1, const_iterator i2, size_t n, char c);

// 把i1和i2之间的字符串替换成迭代器first与last之间的内容
template <class InputIterator>
string& replace (const_iterator i1, const_iterator i2, InputIterator first, InputIterator last);

// 把字符串i1和i2之间的内容替换成il里的所有字符
string& replace (const_iterator i1, const_iterator i2, initializer_list<char> il);

• 添加
  在字符串的末尾添加另一个字符串的内容

// 在字符串的末尾添加另一个字符串str
string& append (const string& str);
string& operator+= (const string& str);
// 在字符串的末尾添加两一个字符串str的subpos后面sublen长度的字符串
string& append (const string& str, size_t subpos, size_t sublen);
// 在字符串的末尾添加字符数组s里的所有内容
string& append (const char* s);
string& operator+= (const char* s);
// 在字符串的末尾添加字符数组s的前n个字符
string& append (const char* s, size_t n);
// 在字符串的末尾添加n个字符c
string& append (size_t n, char c);
// 在字符串的末尾添加一个字符c
string& operator+= (char c);
// 在字符串的末尾添加迭代器first与last之间的字符
template <class InputIterator>
string& append (InputIterator first, InputIterator last);
// 在字符串的末尾添加il里的所有内容
string& append (initializer_list<char> il);
string& operator+= (initializer_list<char> il);

• 赋值
  用新的字符串替换掉本字符串的内容

// 用str替换掉本字符串的内容
string& assign (const string& str);
string& operator= (const string& str);
// 用str里的subpos后面sublen个长度的字符串替换掉本字符串的内容
string& assign (const string& str, size_t subpos, size_t sublen);
// 用字符数组s里的的所有字符替换掉本字符串的内容
string& assign (const char* s);
string& operator= (const char* s);
// 用字符数组s的前n个字符替换掉本字符串里的内容
string& assign (const char* s, size_t n);
// 把本字符串替换成n个字符c
string& assign (size_t n, char c);
// 用迭代器first和last之间的字符替换掉本字符串的内容
template <class InputIterator>
string& assign (InputIterator first, InputIterator last);
// 用il里的所有字符串替换掉本字符串的内容
string& assign (initializer_list<char> il);
string& operator= (initializer_list<char> il);
// 用str替换掉本字符串的内容
string& assign (string&& str) noexcept;
string& operator= (string&& str) noexcept;
// 将字符串的长度置为1，并把字符C填充到字符串里
string& operator= (char c);

• 删除
  删除指定位置后面指定长度的字符

// 删除pos后面len个长度的字符
string& erase (size_t pos = 0, size_t len = npos);
// 删除迭代器p到末尾的所有字符
iterator erase (iterator p);
// 删除迭代器first与last之间的字符
iterator erase (iterator first, iterator last);

• 清空
  清空字符串，得到一个空的字符串

// 清空字符串
void clear() noexcept;

• 为空
  判断字符串的内容是否为空

// 判断字符串是否为空
bool empty() const noexcept;

• 剪切
  得到指定位置后面指定长度的字符串

// 返回pos后面len个长度的字符串
string substr (size_t pos = 0, size_t len = npos) const;

• 比较
  指定位置后面指定长度的字符串与另一个字符串进行比较
  返回值：0，两个字符串相等；
  <0，参与比较的字符串不匹配的第一个字符的值较低，或者所有比较的字符都匹配但参与比较的字符串较短；
  >0，参与比较的字符串不匹配的第一个字符的值更大，或者所有比较的字符都匹配但参与比较的字符串更长。

// 本字符串与str进行比较
int compare (const string& str) const noexcept;
// 本字符串pos后面len长度的字符串与str进行比较
int compare (size_t pos, size_t len, const string& str) const;
// 本字符串pos后面len长度的字符串与str的subpos位置后面sublen长度的字符串进行比较
int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;
// 本字符串与字符数组的所有字符进行比较
int compare (const char* s) const;
// 本字符串pos后面len长度的字符串与字符数组s里的所有字符进行比较
int compare (size_t pos, size_t len, const char* s) const;
// 本字符串pos后面len长度的字符串与字符数组s里前n个字符进行比较
int compare (size_t pos, size_t len, const char* s, size_t n) const;

• 交换
  与另一个字符串交换它们的内容

// 与str交换内容
void swap (string& str);

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

// 将字符串的长度重置为n
void reserve (size_t n = 0);

• 重设
  把字符串重新设置成指定的长度的字符
  如果重设后的长度小于原长度，删除多余的字符
  如果重设后的长度大于原长度，则在结尾处插入空字符或指定的字符到达指定的长度

// 将字符串重设成n个长度的空字符串
void resize (size_t n);
// 将字符串重设成n个长度的c字符
void resize (size_t n, char c);

• 删除末尾字符
  删除字符串末尾的一个字符

// 弹出字符串末尾的一个字符
void pop_back();

• 在末尾添加字符
  在字符串的末尾添加一个字符

// 在字符串的末尾添加一个字符c
void push_back (char c);

• 得到C类型的字符串
  转换成等价的C字符串

// 转换成等价的C字符串
const char* c_str() const noexcept;
// 得到该字符串的数组指针
const char* data() const noexcept;

• 取字符
  得到指定位置处的字符

// 得到指定位置处的字符
char& at (size_t pos);
const char& at (size_t pos) const;
char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;
// 得到字符串的第一个字符
char& front();
const char& front() const;
// 得到字符串的最后一个字符
char& back();
const char& back() const;

• 拷贝
  将字符串的指定内容拷贝到字符数组里

// 将字符串pos处开始的len长度的字符串拷贝到字符数组s里面
size_t copy (char* s, size_t len, size_t pos = 0) const;

• 交换
  交换两个字符串里的内容

// 交换x换y的值
void swap (string& x, string& y);

• 查找
  查找字符串中指定字符或字符串出现的第一处位置
  如果没有匹配的，返回string::npos

// 从字符串的pos处开始查找与字符串str相同的字符串
size_t find (const string& str, size_t pos = 0) const;
// 从字符串的pos处开始查找与字符数组s相同的字符串
size_t find (const char* s, size_t pos = 0) const;
// 从字符串的pos处开始长度为n的范围内查找与字符数组s相同的字符串
size_t find (const char* s, size_t pos, size_t n) const;
// 从字符串串的pos处开始查找与字符c相同的字符
size_t find (char c, size_t pos = 0) const;

查找字符串中指定字符或字符串出现的最后一处位置
如果没有匹配的，返回string::npos

// 查找在字符串pos之前的最后一个与字符串str相匹配的字符串的位置
size_t rfind (const string& str, size_t pos = npos) const noexcept;
// 查找在字符串pos之前的最后一个与字符数组s相匹配的字符串的位置
size_t rfind (const char* s, size_t pos = npos) const;
// 查找在字符串pos之前的n个字符内最后一个与字符数组s相匹配的字符串的位置
size_t rfind (const char* s, size_t pos, size_t n) const;
// 查找在字符串pos之前的最后一个与字符c匹配的字符的位置
size_t rfind (char c, size_t pos = npos) const noexcept;

查找字符串中与其参数中指定的任何字符匹配的第一个字符
如果没有匹配的，返回string::npos

// 查找字符串中的pos处开始与字符串str里的任一字符相同的第一个位置
size_t find_first_of (const string& str, size_t pos = 0) const noexcept;
// 查找字符串中的pos处开始与字符数组s里的任一字符相同的第一个位置
size_t find_first_of (const char* s, size_t pos = 0) const;
// 查找字符串中的pos处开始长度为n的字符串内与字符数组s里的任一字符相同的第一个位置
size_t find_first_of (const char* s, size_t pos, size_t n) const;
// 查找字符串中的pos处开始第一个与字符c相同的位置
size_t find_first_of (char c, size_t pos = 0) const noexcept;

查找字符串中与其参数中指定的任何字符匹配的最后一个字符
如果没有匹配的，返回string::npos

// 查找字符串中的pos之前的所有字符与字符串str里的任一字符相同的最后一个位置
size_t find_last_of (const string& str, size_t pos = npos) const noexcept;
// 查找字符串中的pos之前的所有字符与字符数组s里的任一字符相同的最后一个位置
size_t find_last_of (const char* s, size_t pos = npos) const;
// 查找字符串中的pos之前长度为n的字符串内与字符数组s里的任一字符相同的最后一个位置
size_t find_last_of (const char* s, size_t pos, size_t n) const;
// 查找字符串中的pos之前的所有字符里最后一个与字符c相同的位置
size_t find_last_of (char c, size_t pos = npos) const noexcept;

查找字符串中与指定的字符数组或字符串里的任一字符都不匹配的第一个位置
如果没有找到（即参与比较的部分完全相同），返回string::npos

// 比较字符串pos后面的全部字符与字符串str里的任一字符都不同的第一个字符所在的位置
size_t find_first_not_of (const string& str, size_t pos = 0) const noexcept;
// 比较字符串pos后面的全部字符与字符数组s里的任一字符都不同的第一个字符所在的位置
size_t find_first_not_of (const char* s, size_t pos = 0) const;
// 比较字符串pos后面的n个字符与字符数组s里的任一字符都不同的第一个字符所在的位置
size_t find_first_not_of (const char* s, size_t pos, size_t n) const;
// 比较字符串pos后面的全部字符与字符c不同的第一个字符所在的位置
size_t find_first_not_of (char c, size_t pos = 0) const noexcept;

查找字符串中与指定的字符数组或字符串里的任一字符都不匹配的最后一个位置
如果没有找到（即参与比较的部分完全相同），返回string::npos

// 比较字符串pos前面的全部字符与字符串str里的任一字符都不同的最后一个字符所在的位置
size_t find_last_not_of (const string& str, size_t pos = npos) const noexcept;
// 比较字符串pos前面的全部字符与字符数组s里的任一字符都不同的最后一个字符所在的位置
size_t find_last_not_of (const char* s, size_t pos = npos) const;
// 比较字符串pos前面的n个字符与字符数组s里的任一字符都不同的最后一个字符所在的位置
size_t find_last_not_of (const char* s, size_t pos, size_t n) const;
// 比较字符串pos前面的全部字符与字符c不同的最后一个字符所在的位置
size_t find_last_not_of (char c, size_t pos = npos) const noexcept;

• operator
  重载+运算符
  返回一个新构造的字符串对象，其值为lhs中的字符和rhs中的字符的连接

string operator+ (const string& lhs, const string& rhs);
string operator+ (string&&      lhs, string&&      rhs);
string operator+ (string&&      lhs, const string& rhs);
string operator+ (const string& lhs, string&&      rhs);

string operator+ (const string& lhs, const char*   rhs);
string operator+ (string&&      lhs, const char*   rhs);
string operator+ (const char*   lhs, const string& rhs);
string operator+ (const char*   lhs, string&&      rhs);

string operator+ (const string& lhs, char          rhs);
string operator+ (string&&      lhs, char          rhs);
string operator+ (char          lhs, const string& rhs);
string operator+ (char          lhs, string&&      rhs);

重载==运算符
比较lhs与rhs是否相等

bool operator== (const string& lhs, const string& rhs) noexcept;
bool operator== (const char*   lhs, const string& rhs);
bool operator== (const string& lhs, const char*   rhs);

重载!=运算符
比较lhs与rhs是否不等

bool operator!= (const string& lhs, const string& rhs) noexcept;
bool operator!= (const char*   lhs, const string& rhs);
bool operator!= (const string& lhs, const char*   rhs);

重载<运算符
比较lhs是否小于rhs

bool operator<  (const string& lhs, const string& rhs) noexcept;
bool operator<  (const char*   lhs, const string& rhs);
bool operator<  (const string& lhs, const char*   rhs);

重载<=运算符
比较lhs是否小于等于rhs

bool operator<= (const string& lhs, const string& rhs) noexcept;
bool operator<= (const char*   lhs, const string& rhs);
bool operator<= (const string& lhs, const char*   rhs);

重载>运算符
比较lhs是否大于rhs

bool operator>  (const string& lhs, const string& rhs) noexcept;
bool operator>  (const char*   lhs, const string& rhs);
bool operator>  (const string& lhs, const char*   rhs);

重载>=运算符
比较lhs是否大于等于rhs

bool operator>= (const string& lhs, const string& rhs) noexcept;
bool operator>= (const char*   lhs, const string& rhs);
bool operator>= (const string& lhs, const char*   rhs);

• 输入输出流
  从流中插入/获取字符串

// 从流中提取字符串
istream& operator>> (istream& is, string& str);
// 将字符串插入流
ostream& operator<< (ostream& os, const string& str);

// 从流is中提取一行字符串到str中，直到划分字符delim为止
istream& getline (istream&  is, string& str, char delim);
istream& getline (istream&& is, string& str, char delim);
// 从流is中提取一行字符串到str中，直到换行为止
istream& getline (istream&  is, string& str);
istream& getline (istream&& is, string& str);