C++ 之 string

C++ 的 string 类封装了很多对字符串的常用操作。

string 类是模板类 basic_string类，以 char作为其元素类型的类。

string 以单字节作为一个字符，如果处理多字符集编码的字符串，string仍以一个字节作为单个字符单位。

构造函数

　　(1) string() 　　// 默认构造：构造一个空字符串

　　(2) string(const string &str) 　　// 拷贝构造：复制另一个 string对象的内容

　　(3) string(const string & str, size_t pos, size_t len = npos)　　// 子串构造：以字符串 str的 pos位置开始，长度为 len的子串构造。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 // 如果 len大于字符串长度或者 len为 npos(默认)，则以字符串结束符为结尾构造。

　　(4) string(const char *s)　　// C风格字符串构造：以s开头，NULL结尾的C风格字符串构造

　　(5) string(const char *s, size_t n)　　// C风格字符子串构造：从s中拷贝n个字符构造

　　(6) string(size_t n, char c)　　// 字符填充构造：用 n个字符c构造字符串

　　(7) string(InputIterator first, InputIterator last)　　// 范围构造：用两个string迭代器之间的区域构造字符串

　　还有两种构造 initializer list 和 move constructor 不是很懂

赋值操作符 = 

　　string& operator= (const string& str);　　// 用一个 string 为另一个string 赋值

　　string& operator= (const char *s);　　　　// 用C风格字符串为另一个string 赋值

　　string& operator= (char c);　　　　　　　　// 用一个字符为另一个string 赋值

　　还有另外两种 initializer_list 和 mov constructor 赋值不是很懂

迭代器

　　begin()　　// 返回指向字符串第一个字符的迭代器

　　end()　　　// 返回指向字符串最后一个字符之后的迭代器，不能被解引用

　　rbegin()　  // 返回指向字符串最后一个字符的迭代器

　　rend()　　  // 返回指向字符串第一个字符之前的迭代器，不能被解引用

　　cbegin(), cend(), crbegin(), crend() // 返回上述四种迭代器的 const 版本，不能通过解引用这些迭代器来修改 string，即便string 本身不是const 的

容积

 　 size() 或 length()　　// 返回字符串包含的字符数，以字节作为字符分割，多字节编码的字符串可能不能得到正确字符数

　　　　　　　　　　　　 // size_t size(); size_t length();

　　resize(size_t n) 　// 修改字符串的大小为n

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

　　　　　　　　　　  // 如果字符串的长度小于 n，则n个字符后面的字符被抛弃。

　　　　　　　　　　  // 如果字符串长度大于n，则会延长字符串。如果制定了c，则会用字符c填充字符串，否则后面的字符将被值初始化(初始化为NULL)

  　capacity()　　　　// 返回已经为这个字符串分配的存储空间。capacity()的值一般比字符串长度大一些，以适应对字符串的增补操作。

　 　　　　　　　　　// capacity() 的大小并不限制字符串的长度，当需要长度大于 capacity() 时，会重新分配空间，扩大 capacity()

 　　　　　　　　　　// 可分配的最大长度用成员 max_size() 表示

　　　　　　　　　　 // 使用成员函数 reserve 可以手动调整 capacity()的值

　　　　　　　　　　// size_t capacity();

　　max_size()　　 // 返回字符串最大能分配的存储空间大小，不保证字符串一定能达到这个大小

　　　　　　　　　　// size_t max_size()

　  reserve(size_t n=0)　　// 修改为字符串分配的存储空间为 n，默认为0

　　　　　　　　　　　　　 // 主要用于为 capacity 括容，当 n > capacity 时，会为字符串增加分配空间，但如果 n > max_size ，会抛 std::length_error 异常

　　　　　　　　　　　　　 // 当 n < capacity() 时，相当于一个非绑定的 shrink操作，具体是否会减少存储空间，取决于实现。微软的编译器就不会减少空间，而g++编译器会

　　　　　　　　　　　　　 // 当 n < size() 时，相当于一个非绑定的 shrink_to_fit 操作，具体是否会减少存储空间，也取决于实现。

　　　　　　　　　　　　　 // 当 n < 0 时，会导致程序崩溃

　  　　　　　　　　　　　  // 当需要分配存储空间而失败时，会抛 std::bad_alloc异常

　　　　　　　　　　　　　 // void reserve(size_t n=0);

　　clear()　　　　// 清空当前字符串的所有字符，长度变为0

　　　　　　　　　// void clear();

　　empty()　　　//  测试当前字符串是否为空，若为空返回true， 否则返回false

　　　　　　　　　// bool empty();

　　shrink_to_fit()　　// 将字符串的 capacity 减小到其 size的大小

　　　　　　　　　　　 // 这是一个non-binding的function，具体是否缩小取决于实现

　　　　　　　　　　　 // 如果需要分配存储空间，而分配失败，会抛 std::bad_alloc异常

元素访问

　　操作符[]　　// char& operator[] (size_t pos);　　const char& operator[](size_t pos) const;

　　　　　　　　// 返回字符串中位置在 pos的字符的引用。如果字符串是 const 的，则返回的字符也是 const;

　　　　　　　　// 如果 pos > size(); 会产生 undefined behavior

　　at()　　　　// char& at(size_t pos); 　　const char& at(size_t pos) const;

　　　　　　　  // 功能同[]，不过如果 n > size() 会抛 out_of_range 异常

　　front()　　 // char& front(); 　　const char& front() const;

　　　　　　　  // 返回字符串的第一个字符

　　　　　　　  // 不同于 begin() 返回第一个字符的迭代器，front() 直接返回这个字符的引用

　　　　　　　  // 对一个空字符串调用 front()会产生 undefined behavior

　　back()　　  // char& back();　　const char& back() const;

　　　　　　　　// 返回字符串的最后一个字符，如果对一个空字符串调用，会产生 undefined behavior

 元素修改

　　操作符+=　// 在字符串后面增添新的 string, C风格字符串，单个字符

　　　　　　　  // (1) string& operator += (const string& str);　　　　// 增添 string

　　　　　　     // (2) string& operator += (const char * s);　　　　　 // 增添C风格字符串

　　　　　　　  // (3) string& operator += (const char c);　　　　　　 // 增添单个字符

　　　　　　　  // (4) string& operator += (initializer_list<char> il);　// 不懂

　　　　　　　  // 如果增添后的 length() > max_size() 会抛 length_error 异常

　　　　　　　  // 如果需要分配存储空间时失败，会跑 bad_alloc 异常

　　append()　// 在字符串后面添加新的 string, string子串，C风格字符串，C风格字符子串，n个字符c，迭代器构成的子串

　　　　　　　  // (1) string& append(const string& str);　　　　  // 增添 str

　　　　　　　  // (2) string& append(const string& str, size_t subpos, size_t sublen);　　// 增添str中，由 subpos开始，长度为 sublen的子串。 如果sublen到达字符串尾，或sublen > npos，则以字符串结束符为结束

　　　　　　　  // (3) string& append(const char *s);　　　　　　  // 增添C风格字符串s

　　　　　　　  // (4) string& append(const char* s, size_t n);　　// 增添C风格字符串s的前 n个字符

　　　　　　　  // (5) string& append(size_t n, char c);　　　　　  // 连续增添 n 个字符c

　　　　　　　  // (6) string& append(InputIterator first, InputIterator last);　　// 添加迭代器之间的字符

　　　　　　　  // (7) string& append(initializer_list<char> il);　　// 不懂

　　　　　　　  // 如果 (3)中的 s 为NULL, 或(4)中的 n比s的长度长，都会产生 undefined behavior

　　　　　　　  // 如果 (2)中的 subpos 超过了 str的 length()，会抛 out_of_range异常

　　　　　　　  // 如果append结果的 length() 超过了 max_size()，会抛 length_error异常

　　　　　　　  // 如果在申请空间时失败，会抛 bad_alloc异常

　　push_back(char c)　　// 在string 后面添加一个字符 c

　　　　　　　　　　　　   // void push_back(char c);

　　　　　　　　　　　　　// 如果添加后，超过了 max_size()，则抛 length_error异常

　　　　　　　　　　　　   // 如果在申请空间时失败，会抛 bad_alloc异常

　　pop_back()　// 删除string 最后一个字符

　　　　　　　　  // void pop_back();

　　assign()　　// 用一个新的字符串替代原有字符串

　　　　　　　　// (1) string& assign(const string& str)　　// 用string 替换 string

　　　　　　　　// (2) string& assign(const string& str, size_t subpos, size_t sublen);　　// 用str 的子串替换 string

　　　　　　　　// (3) string& assign(const char *s)　　// 用C风格字符串替换 string

　　　　　　　　// (4) string& assign(const char *s, size_t n)　　// 用C风格字符串的前 n个字符替换 string

　　　　　　　　// (5) string& assign(size_t n, char c)　　// 用 n个字符c 替换string

　　　　　　　　// (6) string& assign(InputIterator first, InputIterator last);　　// 用迭代器间的内容替代 string

　　　　　　　　// (7) string& assign(initializer_list<char> il);　　　　// 不懂

　　　　　　　　// (8) string& assign(string&& str) noexcept;　　　　 // 不懂

　　　　　　　　// 除了(8) 不抛异常以外，其他异常情况与 append() 相同

　　insert(size_t pos, ...)　　// 在制定位置之前插入字符串

　　　　　　　　// 支持 string, string子串，C风格字符串，C风格字符串前n个字符，n个字符c的插入方法

　　erase()　　 // 清除字符串的一部分

　　　　　　　　// string& erase(size_t pos=0, size_t len=npos);　　// 清除从pos开始长度为len 的字符子串。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 // 如果len > size() 则清除到字符串结尾。默认参数是清除整个字符串。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 // 如果pos > length() 抛一个out_of_range异常，pos 可以等于 length() 这时，什么都不清除

　　　　　　　　// iterator erase(const_iterator p);　　　清除 p指向的字符，返回被删除字符那个位置的迭代器

　　　　　　　　// iterator erase(const_iterator first, const_iterator last);　　清除迭代器[first, last)之间的内容， 返回原来first字符那个位置的迭代器

　　replace()　  // 将原字符串一段区域内的子串删除，并用一个新的字符串替换它

　　　　　　　　// 支持用 pos,len 的方式1 表示被删除的子串，如果pos > length() 会抛一个out_of_range异常。如果 pos == length() 则相当于在字符串后面添加。

　　　　　　　　// 如果 pos+len 超过了字符串尾，则将 pos后的字符串全部换成新的 string

　　　　　　　　// 支持用 const_iterator i1, const_iterator i2 的方式2 表示被删除的子串[i1, i2)

　　swap()　　  // 交换两个string 的内容

　　　　　　　   // void swap(string &str);

　　　　　　　　// 另有非成员重载函数 void swap(string &str1, string &str2);

字符串操作

　　c_str()　　// 获得等效的 C风格字符串

　　　　　　　 // const char *c_str() const;

　　　　　　　 // 返回的指针是 string 用于存放字符串的实际指针。如果修改了返回值 char *c 的内容，string 同样也会被修改。(虽然返回值要求是 const char* 的，但是也可以通过强制类型转换修改它的值)

　　　　　　　 // 如果后续对string 进行了操作，那么前面得到的 char *s 可能会失效

　　data()　　 // 与 c_str() 完全相同

　　get_allocator()　　// 不懂

　　copy()　　  // size_t copy(char *s, size_t len, size_t pos=0) const;

　　　　　　　　// 在string中拷贝一个子串 到char *s 指向的字符串中。返回实际拷贝的字符数。

　　　　　　　　// 子串从 pos 开始，长度为len。如果pos > length()，抛一个 out_of_range 异常。如果 pos+len 超过string尾，则将pos 到字符串结束的所有字符拷贝。

　　　　　　　　// 如果 s 为空，或者不足够存放被拷贝的子串，则导致 undefined behavior

　　　　　　　　// copy() 方法不会自动添加字符串结束符 \0，如果copy导致覆盖了原有的\0，字符串会丢失结尾

　　find()　　　// 查找目标字符串在源字符串中第一次出现的位置，返回这个位置。如果找不到，返回 string::npos

　　　　　　　　// size_t find(const char& str, size_t pos = 0) const;　　　　　　// 查找 string

　　　　　　　　// size_t find(cosnt char* s, size_t pos=0) const;　　　　　　　  // 查找 C风格字符串

　　　　　　　　// size_t find(const char *s, size_t pos, size_type n) const;　　  // 查找 C风格字符串的前n 个字符

　　　　　　　　// size_t find(char c, size_t pos=0) const;　　　　　　　　　　　  // 查找单个字符 c

　　　　　　　　// 如果指定了 pos，那么就是对源字符串从 pos开始查找，pos之前的一律不管

　　　　　　　　// 如果 s不是一个字符串，或长度不够则产生 undefined behavior

　　rfind()　　  // 查找目标字符串在源字符串中最后一个出现的位置

　　　　　　　　// 大体上和 find() 相同，不过 pos表示 作为查找起点的最后一个点

　　find_first_of // 查找指定字符串中的任意一个字符第一次出现的位置

　　　　　　　　  // 重载情况与 find()基本相同，只不过支持不是匹配整个字符串，而是匹配制定字符串中的任意一个字符。

　　find_last_of  // 查找指定字符串中的任意一个字符最后一次出现的位置

　　　　　　　　  // find_first_of 的反向

　　find_first_not_of // 查找不属于制定字符串中任意一个字符的字符第一次出现的位置

　　　　　　　　  　　// 重载情况与 find_first_of ，不过这次是匹配除制定字符串以外的任意字符

　　find_last_not_of // 查找不属于制定字符串中任意一个字符的字符最后一次出现的位置

　　　　　　　　  　　// 重载情况与 find_first_of ，不过这次是匹配除制定字符串以外的任意字符

　　substr　　// 产生一个子串

　　　　　　　// string substr(size_t pos=0, size_t len=npos) const;

　　　　　　　// 将源字符串 pos 开始，长度为 len 的部分作为子串返回

　　　　　　　// 如果 pos == length() 那么返回的是一个空串， 如果 pos > length() 抛 out_out_range 异常

　　　　　　　// 如果 pos + len 超过字符串尾，那么把 pos 到字符串尾的所有字符作为子串返回

　　compare　　// 将字符串进行对比

　　　　　　　　 // int compare(const string& str) const; 　　//将两个 string 对比

　　　　　　　　 // int compare(size_t pos, size_t len, const string& str) const;　　　// 将一个子串与 string 对比

　　　　　　　　 // int compare(size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;　　//对比两个子串

　　　　　　　　 // int compare(const char *s)　　// 与C风格字符串对比

　　　　　　　　 // int compare(size_t pos, size_t len, const char *s)　　// 与C风格字符串对比

　　　　　　　　 // int compare(size_t pos, size_t len, const char *s, size_t n)　　// 子串与C风格字符串的前 n个字符对比

　　　　　　　　 // 返回 0 ：字符串相等

　　　　　　　　 // < 0 : 要么是 string 对象第一个与对比字符串不同的字符比较小，或者是 string是对比字符串的一个前缀。

　　　　　　　　 // > 0 : 要么是 string 对象第一个与对比字符串不同的字符比较大，或者是 对比字符串是string的一个前缀。

特殊常量

　　string::npos　　// 这是一个用于表示最大字符串长度的变量。实际字符串不可能达到这个长度

　　　　　　　　　　// 这是一个无符号整形变量，其值为 -1。但是一定不能将其做这种对比 npos < 0 ，由于 npos 是无符号整形，-1代表无符号整形的最大值，所以 npos < 0 为 false

非成员函数重载

　　+ 操作符　　// 拼接两个字符串，组成一个新的 string 返回

　　　　　　　　// 支持 string+string 　　string + char*　　string + char

　　关系运算符　// 对比两个字符串，支持 string 与 string ， string 与 char* 的对比

　　　　　　　　// 包括 > 　　>= 　　< 　　<=　　 ==　　!= 

　　　　　　　　// 实际是调用了 compare()

　　swap　　　 // 交换两个 string ，前面已经提过

　　>> 操作符　// 从流中读入 str, str原来的值被覆盖，遇到分隔符会停止读入str

　　<< 操作符   // 从 str写入输出流

　　getline　　  // 从流中读入字符写入 str中，如果制定了结束字符，则遇到结束字符停止。否则遇到换行符停止。

　　　　　　　　 // istream& getline(istream& is, string& str, char delim);　　// 以 delim停止

　　　　　　　　 // istream& getline(istream& is, string& str);　　// 以换行符停止