stl容器 string类的基本操作

一.string类的构造

二.string类的输出

1.传统字符串输出

2.通过迭代器进行输出

编辑 3.C++11标准的范围for输出加auto推导类型

三.string类的各种迭代器

begin(）和end()

利用迭代器遍历输出

利用迭代器修改字符串的字符

rbgin()和rend()

利用迭代器遍历输出

cbegin()和cend()

利用cbegin()和cend()进行遍历输出

crbegin()+crend()

利用迭代器进行遍历输出

四.string类对字符串进行修改的相关操作

assign清空然后重新赋值

字符串后面加上另一个字符串

插入和删除字符

push_back插入和pop_back删除

编辑 insert插入和erase删除

指定位置插入另一个string对象或者字符串

在指定位置插入另一个字符串的子串

在指定位置插入字符串规定长度的字符

在指定位置插入n个指定的字符

通过迭代器控制插入位置，插入单个字符。

用迭代器控制一段区间插入

五.string类查找，替换和取子串

find查找

replace替换

取子串substr

六.string类对象的容量操作

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 不会反映这些数据的大小。