目录
编辑 3.C++11标准的范围for输出加auto推导类型
string类在使用的时候要包括头文件#include<string>
一.string类的构造
第一个是构造一个空string类
第二个是用一个string类对象去拷贝构造另一个string类
第三个是指从另一个string类型的哪个位置（pos）开始复制多少个字符构造另一个string类
第四个是用一个具体的字符串直接构造string类
第五个是用字符串的几个字符去构造string类
第六个是用n个c字符去构造string类，c字符可以换成别的字符
第七个是用另一个string类对象的迭代器范围构造string类对象，迭代器用法暂时看做指针，也就是用前后两个指针中间的内容去构造string类。迭代器一般是左闭右开的
下面具体讲讲他们的用法
string (const char* s);用一个具体的字符串直接构造string类，这是最常见的构造string类的方法
string类和字符串并不等同，字符串是具体内置类型，而string是表示字符串的类，这个类里面有很多处理字符串的函数。
也可以用变量存字符串或者字符串数组来构造string类对象，然后用变量名来进行构造string类
string (const char* s, size_t n);用某个字符串的几个字符去构造string类s1.size()和s1.length()都是获取字符串有效字符长度，都不会计算\0
比如下面的例子用str字符串的3个字符去构造str，所以打印str只有str前三个字符
string (const string& str);用一个已经构造出来的string类对象去拷贝构造另一个string类，本质上就是执行了一次拷贝构造
string (const string& str, size_t pos, size_t len = npos);是指从另一个string类型的哪个位置（pos）开始复制多少个字符构造另一个string类
string s2(s1,1,3); 1是指从字符串下标为1（包括下标为1的字符）的地方开始往后复制，3是指复制多少个字符，也就是从1开始包括1往后数3个字符，也就是bcd
也可以不写要复制多少个字符，那么它就会从那个位置开始一复制到最后一个字符
如果设定的要复制的个数大于被复制的整个字符串的长度，那么也会一直复制最后一个字符
为什么会这样呢，实际上它复制遇到被复制的字符串\0就会直接停止，不会往后继续复制了
string (size_t n, char c);用n个c字符去构造string类，c字符可以换成别的字符，这个不怎么用
template <class InputIterator> string (InputIterator first, InputIterator last);是用另一个string类对象的迭代器范围构造string类对象，迭代器用法暂时看做指针，也就是用前后两个指针中间的内容去构造string类。迭代器一般是左闭右开的
迭代器看做指针的话，那么s1.begin()实际上指的是s1字符串的第一个元素，也就是字符a，而s1.end()指的是最后一个元素的下一个字符，也就是f之后
同时因为迭代器和指针很像，所以迭代器也可以加减偏移量 来控制两个迭代器之间的范围大小
二.string类的输出
1.传统字符串输出
字符串也可以像数组一样用[ ]和下标进行访问，所以可以借助下标来进行输出
2.通过迭代器进行输出
迭代器用法可以看做和指针一样的用法（不等同于指针），所以可以像指针一样解引用来访问字符串里的元素
也可以用auto自动推导类型来简化i的类型写法，但是auto是C++11的标准，不支持C++11标准的编译器会直接报错
3.C++11标准的范围for输出加auto推导类型
这种范围for输出就是把要输出的字符串或者数组之类的切成一份份的然后赋值给c，直接输出c就可以了。不过非C++11标准也用不了
三.string类的各种迭代器
string类有八种迭代器（C++11标准下），四种组合
| 迭代器组合 | 功能说明 | 迭代器类型 |
| begin()+end() | 正向起始迭代器+正向结束迭代器 | iterator |
| rbegin()+rend() | 反向起始迭代器+反向结束迭代器 | reverse_iterator |
| cbegin()+cend() | 正向常量起始迭代器+正向常量结束迭代器 | const_iterator |
| crbegin()+crend() | 反向常量起始迭代器+反向常量结束迭代器 | const_reverse_iterator |
begin(）和end()
begin（）和end（）字符串中的位置显示
利用迭代器遍历输出
利用begin()和end()迭代器进行遍历字符串输出
写完整迭代器类遍历的情况，string::iterator i
利用迭代器修改字符串的字符
rbgin()和rend()
rbegin()和rend()在字符串中位置
利用迭代器遍历输出
rbegin和rend遍历字符串输出，rbegin和rend是反向迭代器，所以输出是反的字符串
写完整迭代器类遍历的情况，string::reverse_iterator i
利用迭代器修改字符串的字符
cbegin()和cend()
cbegin()和cend()指向位置和输出都与begin()以及end()一样，只是加了一层const限制了不能修改，所以用c系列的迭代器都不能利用迭代器去修改字符串中的字符
在字符串中指向的位置
利用cbegin()和cend()进行遍历输出
crbegin()+crend()
crbegin()和crend()指向位置和输出都与rbegin()以及rend()一样，只是加了一层const限制了不能修改，所以用c系列的迭代器都不能利用迭代器去修改字符串中的字符
在字符串中指向的位置
利用迭代器进行遍历输出
四.string类对字符串进行修改的相关操作
assign清空然后重新赋值
assign会把原字符串的内容先全清空，然后再赋值为括号里给的字符串
字符串后面加上另一个字符串
一种方法是append，这种不常用了，所以不细讲了
示例
另一种方法是直接通过+号或者+=号来实现，string类自带重载+号和+=号
插入和删除字符
push_back插入和pop_back删除
这种插入是尾部插入和尾部删除
insert插入和erase删除
这种插入删除要灵活一点，它可以在指定位置插入，甚至可以将一整段区间字符插进去
| string (1) | string& insert (size_t pos, const string& str); |
|---|---|
| substring (2) | string& insert (size_t pos, const string& str, size_t subpos, size_t sublen); |
| c-string (3) | string& insert (size_t pos, const char* s); |
| buffer (4) | string& insert (size_t pos, const char* s, size_t n); |
| fill (5) | string& insert (size_t pos, size_t n, char c);
void insert (iterator p, size_t n, char c);
|
| single character (6) | iterator insert (iterator p, char c); |
| range (7) | template <class InputIterator> void insert (iterator p, InputIterator first, InputIterator last); |
指定位置插入另一个string对象或者字符串
string& insert (size_t pos, const char* s)和string& insert (size_t pos, const char* s);类似
在指定位置插入另一个字符串的子串
string& insert (size_t pos, const string& str, size_t subpos, size_t sublen); size_t pos是要插入的位置，用的是数组下标。const string& str是要插入的另一个字符串，size_t subpos是要截取子串的起始位置，用的也是数组下标。 size_t sublen是要截取子串的长度（长度用的是物理下标，从1开始），如果不写的话会一直截取到最后
在指定位置插入字符串规定长度的字符
string& insert (size_t pos, const char* s, size_t n); size_t pos是要插入的位置，const char* s是要插入的字符串，size_t n插入字符串的长度，从0开始算。n写得超过了字符串长度会把整个字符串都插进去
在指定位置插入n个指定的字符
string& insert (size_t pos, size_t n, char c);用数组下标去控制插入位置
void insert (iterator p, size_t n, char c);用迭代器控制插入位置，可以用加减偏移量来辅助完成
数组下标形式
迭代器形式
通过迭代器控制插入位置，插入单个字符。
begin()一开始是默认在下标为0的位置，通过加减偏移量就可以控制插入的位置了
用迭代器控制一段区间插入
template <class InputIterator>
void insert (iterator p, InputIterator first, InputIterator last);iterator p指要插入的地方（用迭代器指向来实现的，不能换成数组下标串用），InputIterator first和InputIterator last形成区间，这段区间的字符就是要插入的字符串。这两个都是迭代器，用两个迭代器形成区间插入
五.string类查找，替换和取子串
find查找
| string (1) | size_t find (const string& str, size_t pos = 0) const; |
|---|---|
| c-string (2) | size_t find (const char* s, size_t pos = 0) const; |
| buffer (3) | size_t find (const char* s, size_t pos, size_t n) const; |
| character (4) | size_t find (char c, size_t pos = 0) const; |
find查找操作概括一下就三种，要么给查找的长度，超过这个长度就算后面有符号符合查找的符号也返回没找到，比如size_t find (const char* s, size_t pos, size_t n) const;。要么就是不给查找长度，直接给从哪里开始查找的位置，这样就会一直查找到最后，比如size_t find (const char* s, size_t pos = 0) const;。还有一直就是只给待查找的字符串，不给从哪里开始，到哪里结束，例如size_t find (const char* s) const;，这样查找是一直从头查找到尾。
find如果能找到那么返回的是被查找的字符的数组下标，如果没找到返回的是nops，nops是一个特定的常量值，表示 std::string::size_type 类型的最大值。在 C++ 中，std::string::size_type 通常是一个无符号整数类型（如 size_t），因此npos 的值是这种类型可以表示的最大值。
不过一般不会去打印nops的值，直接用等不等于nops来判断是否查找到就可以了，比如下面的代码
#include <string>
#include <iostream>
using namespace std;
int main() {
string str = "Hello, World!";
size_t pos = str.find("Universe");
if (pos == string::npos) {//每个stl类的npos不同，所以要用类域
cout << "没找到!" << endl;
}
else {
cout << "位置是: " << pos << endl;
}
return 0;
}
如果是查找字符串的话，比如在"abcdefghtf"查找ab的位置，返回的第一个字符的下标也就是a的下标0
限定范围的查找例子，在 "abcdefghtf"里查找gh，但是我范围只限定到gh的前面字符f的位置
rfind查找是从后面开始查找，返回的也依旧是该字符在字符串里的位置
比如下面的例子，虽然有两个ab，但是是从后面开始找，所以返回的后面那一个ab的位置
replace替换
| string (1) | string& replace (size_t pos, size_t len, const string& str); string& replace (iterator i1, iterator i2, const string& str); |
|---|---|
| substring (2) | string& replace (size_t pos, size_t len, const string& str,
size_t subpos, size_t sublen);
|
| c-string (3) | string& replace (size_t pos, size_t len, const char* s); string& replace (iterator i1, iterator i2, const char* s); |
| buffer (4) | string& replace (size_t pos, size_t len, const char* s, size_t n); string& replace (iterator i1, iterator i2, const char* s, size_t n); |
| fill (5) | string& replace (size_t pos, size_t len, size_t n, char c); string& replace (iterator i1, iterator i2, size_t n, char c); |
| range (6) | template <class InputIterator>
string& replace (iterator i1, iterator i2,
InputIterator first, InputIterator last); |
第一种string& replace (size_t pos, size_t len, const string& str); size_t pos是开始替换的位置， size_t len是要指定的要替换的长度，但是如果你要替换的字符串比你指定的字符串长度要长的话会直接全复制过去，如果被替换的字符串不足要替换的字符串的话，会自动把没替换的自动添加到字符串后面
举个例子
8是起始位置的索引，表示从字符串s1的第 9 个字符（因为索引是从 0 开始的）开始替换。3是要替换的字符数，表示从第 9 个字符开始，替换接下来的 3 个字符。"hello bit"是替换字符串，即要用这个字符串替换掉从第 9 个字符开始的 3 个字符。
这里有一个关键点：replace 函数会替换指定数量的字符，即使替换字符串的长度超过了这个数量。在你的例子中，虽然只指定了替换 3 个字符，但是 "hello bit" 的长度超过了 3，所以 replace 函数会用整个 "hello bit" 字符串替换从索引 8 开始的 3 个字符（如果存在的话）。如果原始字符串 s1 在索引 8 之后没有足够的字符来替换（即不足 3 个字符），那么 replace 函数只会替换到原始字符串的末尾。
第二种string& replace (iterator i1, iterator i2, const string& str); iterator i1, iterator i2这两个迭代器形成了一个区间，把这两个迭代器之间的内容全部替换成规定的字符串
第三种另一个字符串的子串替换
string& replace (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen); ，与第一种替换相比其实就是多了取字符串子串的两个变量而已，size_t subpos是要替换过去的字符串子串的开始位置，size_t sublen是要替换过去子串的长度
下面的例子里，第一个3指的是在s1下标为3的地方开始替换，后面的3指的是要被替换多少的字符，按这个原定计划是把s1的def给替换了。后面的0指的是s2要替换过去的子串从0开始取子串，取长度为5的子串替换过去。虽然s1设定了只被换3个字符，但是是远小于要求替换的子串长度5的，实际执行s1被替换的依旧是def，但是把hello全填上去了，剩下的没被替换的全部挪到后面
第四种string& replace (size_t pos, size_t len, const char* s, size_t n); string& replace (iterator i1, iterator i2, const char* s, size_t n);和第一种类似就不多加赘述了
第五种string& replace (size_t pos, size_t len, size_t n, char c);是在指定位置替换成n个指定的字符，pos是开始被替换的位置，len是被替换的字符个数
以下图举例，虽然要替换的字符是5个n，但是我设置只能被替换3个字符（size_t len决定的），所以最终虽然5个n都填上去了，但是只有def被换了
string& replace (iterator i1, iterator i2, size_t n, char c);
与上面的类似，只是采用迭代器来控制替换范围而已，我想要替换def，只需要一个迭代器执行d，另一个迭代器指向f就可以了，d在数组中的下标是3，所以往后加偏移量3就可以了，f在数组中的下标是5，为什么往后加偏移量6。迭代器控制范围一般是左闭右开的，所以我虽然下标是5，但是我要替换它偏移量要到6
第六种范围替换
template <class InputIterator> string& replace (iterator i1, iterator i2, InputIterator first, InputIterator last); 其实就是把要替换的字符和被替换的字符都用迭代器表示范围而已
下图的例子把def替换成hello，def在s1里迭代器范围是s1.begin()+3到s1.begin()+6与他们的数组下标决定的，同样hello在数组中开头字符h下标为0，所以begin()不用加偏移量，因为它本来就指向这里，而结尾字符o在数组中下标为4，左闭右开所以右边界偏移量要加到5
取子串substr
string substr (size_t pos = 0, size_t len = npos) const; pos是要取子串的开始位置（数组下标从0开始），len是指取子串的长度（从1开始数）
比如下图的例子，把s1里面的子串cde取出来，这个子串的开始字符c下标是2，所以从2开始往后取3个字符
六.string类对象的容量操作
s1.size()和s1.length()都是获取字符串有效字符长度，都不会计算\0，不要和sizeof（）与length搞混了。stl里这两个都只算有效字符，不会算\0
capacity()返回空间总大小
为什么上图的size capacity sizeof差别那么大呢
size()方法：size()方法返回的是std::string对象中当前存储的字符数（不包括结尾的空字符'\0'）。capacity()方法：capacity()方法返回的是std::string对象在不需要重新分配内存的情况下可以存储的字符的最大数量。这通常是一个大于或等于size()的值，因为std::string可能会为了效率而预先分配额外的内存空间。sizeof运算符：sizeof运算符返回的是对象或类型在内存中所占用的字节数。对于std::string对象，sizeof返回的是std::string类实例（包括其成员变量，如指向字符数组的指针、大小、容量等）的大小，而不是它实际存储的字符数组的大小。因为std::string使用动态内存分配来存储字符数据，所以sizeof不会反映这些数据的大小。
那么他们是怎么扩容的呢，可以通过循环来查看扩容的情况
从上图可以看出容易满了之后并不是一个一个增加的， vs编译器大概是按照1.5倍来进行扩容的（只是一个大概）
来看看dev c++里的扩容情况
从上图可以看出dev c++扩容是严格按照2倍来进行扩容的，所以不同的编译器会有不同的编译规则
empty()检测字符串是否为空串，是就返回true（0），否则就返回false（1）。clear()清空有效字符
reserve()为字符串预留空间，每次不过空间容量，虽然扩容是按倍数扩容的，但还是有点麻烦。
所以如果我们预先知道了要使用多大空间，就可以用reserve预留空间，就不用扩容了
先来看看dev c++的情况
再来看看vs的情况
为什么vs是159而dev c++是150
Dev-C++ 通常使用 MinGW 或类似的 GCC 编译器，而 Visual Studio 使用 Microsoft 的 MSVC 编译器。它们之间的 std::string 实现可能有所不同。
在 Dev-C++ 中，调用了 reserve(150)，std::string 不会在每次添加字符时都立即增加其容量。相反，它可能会等待直到达到某个阈值或满足某个条件时，才分配更多的内存。这就是为什么看到的 capacity() 可能一直为 150 的原因。
在 Visual Studio 中，std::string 的实现可能会更加积极地分配内存，以确保在添加更多字符时不需要频繁地重新分配内存。也就是说即使你预定空间了，但是它害怕你预定的不够，所以会多开一点
如果我先预留了一个大的空间容量，然后又预留小的空间容量，最终空间容量会不会缩小呢
从上图可以看出来，vs编译器不会进行缩容，而dev c++会缩容，这也是因为两个编译器实现机制不一样。但是反过来扩大预留容量还是可以的
resize()将有效字符个数改成n个，多余的字符用c替代
下面例子里因为我设置了有效字符为5，所以只会打印前5个字符
