目录
1 Modifiers部分
1.1 assign的使用
1.2 insert的使用
1.3 erase的使用
1.4 replace的使用
2 capacity部分
2.1 max_size的使用
2.2 capacity的使用
2.3 reserve的使用
2.4 shrink_to_fit简介
2.5 resize的使用
2.6 clear的使用
3 String operations部分
3.1 c_str的使用
3.2 copy的使用
3.3 find和rfind的使用
3.4 substr的使用
3.5 find_first_of(not)和find_last_of(not)的使用
3.6 compare的使用
4 Non-member function overloads部分
4.1 operator+的使用
4.2 relational operators
4.3 operator<< 和 operator>>的使用
4.4 getline的使用
5 补充函数
6 有关编码
1 Modifiers部分
上文已经介绍了+=，append，push_back，pop_back，这里介绍assign，insert，erase，replace。
1.1 assign的使用
assign的使用类似于赋值，会完全覆盖原来的字符串，进行赋值：
int main()
{
string s1("Hello world");
s1.assign("xx");
cout << s1;
return 0;
}
但是查看文档就发现函数重载挺冗余的，实际上常用的也就是第三个了，类比的化，第二个也可以连蒙带猜的试一下：
int main()
{
string s1("Hello world");
string s2("123456789");
s1.assign(s2,2,5);
cout << s1;
return 0;
}1.2 insert的使用
insert在链表中使用过，当然是名字使用过，插入的意思，有意思的是string没有直接的支持头插，但是间接的支持了头插，可以使用insert进行实现：
int main()
{
string s1("Hello world");
string s3 = "123456";
s3.insert(0,s1);
cout << s3 << endl;
return 0;
}第一个重载的使用如上，pos位置插入数据，打印出来就是Hello world123456，类似的是第三个：
int main()
{
string s3 = "123456";
s3.insert(0,"132");
cout << s3 << endl;
return 0;
}当然还有迭代器版本的，前四个函数挺类似的，不作介绍，这里介绍一下迭代器版本的：
int main()
{
string s1("123456");
string s2("Hello world");
s1.insert(s1.end(), s2.begin(), s2.end());
cout << s1 << endl;
return 0;
}第一个参数是选择插入的位置，后面是区间，但是注意的是这个区间是左闭右开的。
但是离谱的是insert不支持直接插入单个字符，要插入单个字符使用第四个函数重载：
int main()
{
string s1("123456");
s1.insert(0, 1, 'x');
cout << s1 << endl;
return 0;
}有疑问了就，可以插入一个只有一个字符的字符串，但是这种情况只能这样写：
int main()
{
string s1("123456");
char ch = 'a';
s1.insert(0, 1, ch);
cout << s1 << endl;
return 0;
}
但是不太推荐使用，因为它的时间复杂度是O(N)，底层的实现原理是移动每个数据到相应位置，时间复杂度即一个循环，是O(N)。
1.3 erase的使用
有插入就会有删除，erase即删除:
参数问题现在已经不大了，使用如下：
int main()
{
string s1("abcdefg");
s1.erase();//清空字符串
cout << s1 << endl;
string s2("abcdefg");
s2.erase(0);//清空字符串
cout << s2 << endl;
return 0;
}int main()
{
string s3("abcdefg");
s3.erase(0, 3);//abc清空
cout << s3 << endl;
string s4("abcdefg");
s4.erase(s4.begin(), s4.begin() + 4);//abcd清空
cout << s4 << endl;
return 0;
}迭代器和npos的使用如上，但是仍然不推荐使用，因为和insert是一样的，时间复杂度为O(N)。
因为缺省值是npos，所以删除的长度可以离谱但是下标不能离谱：
int main()
{
string s5("abcdefg");
s5.erase(2,100);
cout << s5 << endl;
return 0;
}1.4 replace的使用
replace的英文是代替，顾名思义咯~
多吧？第一个函数重载使用如下：
int main()
{
string s1("123456");
s1.replace(2,2,"a");
cout << s1 << endl;
return 0;
}
从3开始把两个字节替换成a字符。
为什么说它坑呢？引入一道题，将一段字符串中的所有空格全部替换为x,用C语言就是:
int main()
{
string s2("hello world hello Byte");
for(int i = 0;i < s2.size();i++)
{
if (s2[i] == ' ')
{
s2[i] = 'x';
}
}
cout << s2 << endl;
return 0;
}用C++的replace就是：
int main()
{
string s3("hello world hello Byte");
for (int i = 0; i < s2.size(); i++)
{
if(s3[i] == ' ')
{
s3.replace(i,1,"x");
}
}
cout << s3 << endl;
return 0;
}看似没有差别？因为这里的空格刚好是一个字符，如果是还要涉及数据移动的问题，效率自然就低下了，所以慎用。
当然方法很多，多多选择。
2 capacity部分
上篇已经介绍了，size,length,本文介绍max_size,resize,capacity,reserve,clear,shrink_to_fit。
2.1 max_size的使用
这个函数实际上是一个冗余的设计，即一个字符串能开到多大：
int main()
{
string s1("123456");
cout << s1.size() << endl;
cout << s1.max_size() << endl;
return 0;
}max_size()的结果是看64位还是32位情况，64位是：
32位是：
虽然结果不一样，但是大小都是挺惊人的，因为它只有这一个功能，实际上也没有哪个字符串会开这么大，就了解一下即可。
2.2 capacity的使用
由前面的学习可以得知capacity是容量的意思，所以当我们调试一个字符串的时候总会发现：
一个串里面有size,有capacity，有其他元素，那么空间不够了，capacity就会自动扩容，我们要了解的就是它的扩容规则：
int main()
{
string s1("123456");
cout << "Now capacity:" << s1.capacity() << endl;
for (int i = 0; i < 200; i++)
{
s1.push_back('x');
if (s1.capacity() == s1.size())
{
cout << "Capacity Changed:" << s1.capacity() << endl;
}
}
return 0;
}
尾插200个数据，使其扩容：
结果如下，我们可以发现扩容的方式很奇怪，一开始是约等于2倍，后面逐渐变成了1.5倍
这是Vs环境下的扩容，在Linux环境下就是标准的2倍扩容：
但是实际上呢，这里的capacity都是少了一个单位的，比如上面的应该是16，32，38，71，因为要给斜杠0预留一个空间。
可以看到不同的编译器实现扩容的时候有一定差异，Vs下的编译器的是clang，Linux环境下的编译器是g++，实现的时候都有差异，但是不管Vs还是Linux，capacity都是少了1的，因为斜杠0.
2.3 reserve的使用
reserve？reverse？傻傻分不清咯~
reverse是逆置，而reserve的中文意思是预存，保留，是用来开空间的：
它实际影响的只有capacity，不会影响size：
int main()
{
string s1("123456");
cout << s1.size() << " " << s1.capacity() <<endl;
s1.reserve(100);
cout << s1.size() << " " << s1.capacity() <<endl;
return 0;
}
我们开了100个空间，但是实际上开了111个空间？
Linux环境下还是老老实实的要多少开多少。
所以reserve和capacity一样，平台直接有差异。
reserve还可以用来进行缩容,但是因为vs默认是不缩容的，所以这里呢给个结论：
如果缩容，最低只能缩容到15(实际是16)，因为string有一个成员是buff数组，如果string的长度不超过16就会存到buff数组上去，就不用在堆上单独开开空间了，因为数组的大小是定的，16，所以再怎么缩容，都不会比15小。
但是也不是一无用处这个函数，比如涉及到多次开空间的题目，我们可以提前开好，省略了一下开空间的步骤，效率稍微高一点。
2.4 shrink_to_fit简介
这个函数是缩容，但是是在C++11中引进的，虽然可以实现我们想要的功能，但是实际上内存越来越发达的时代，我们更多的追求的是效率，空间不够的情况是比较少见的，而且这个函数使用代价挺大的，我们大多数人以为的缩容是这样的:
有一块空间，释放到不需要的部分，但是在动态内存管理章节我们知道，释放空间不能一段一段的释放，只能一整块的释放，所以实际的缩容是把原来的空间释放掉，重新开一块我们想要的小空间，这个代价挺大的，所以不推荐使用。
2.5 resize的使用
前文提及，capacity的扩容只会影响capacity，不会影响size，但是resize两个都会影响到：
int main()
{
string s1("123456");
cout << s1.size() << " " << s1.capacity() << endl;
s1.resize(100);
cout << s1.size() << " " << s1.capacity() << endl;
s1.resize(5);
cout << s1.size() << " " << s1.capacity() << endl;
return 0;
}
如果我们是resize100的话，6后面的就全是斜杠0了，但是如果我们缩容，就会删除一部分数据，比如这里的6就被删除了。
int main()
{
string s2("hello world");
s2.resize(20, 'x');
cout << s2 << endl;
return 0;
}
resize插入数据会扩容，这里就是在d后面插入x知道字符串长度为20。
也可以当删除使用，size小于原来的size就可以了。
2.6 clear的使用
clear清除，使用起来还是很简单的：
int main()
{
string s1("123456");
cout << s1 << endl;
s1.clear();
cout << s1 << endl;
return 0;
}清除完毕。
3 String operations部分
前文已经介绍了，，，前文没有介绍，嘿嘿，这里介绍c_str,copy,find,rfind,find_first_of,find_last_of,fin_first_not_of,find_last_not_of,substr,compare。
对于get_allocator简单掠过，它涉及到了配置器，就不多介绍了。
3.1 c_str的使用
c_str返回的是字符串的指针，c++和C语言混用的使用就可能有点坑：
int main()
{
string file("Test.cpp");
FILE* fout = fopen(file.c_str(), "r");
char ch = fgetc(fout);
while (ch != EOF)
{
cout << ch;
ch = fgetc(fout);
}
return 0;
}比如这里的fopen不加file. 的话，那么c_str就读取不到了，但是在C语言里面这里都是直接放的指针，没有考虑其他的，C++考虑的还要多一些。
当然函数本身的使用还是很简单的，返回指针而已。
3.2 copy的使用
copy的本质是赋值，但是不是给string类的赋值，是给字符数组赋值，并且返回值是赋值过去的字符串长度，可以理解为返回的是len
int main()
{
string s1("abcdefg");
char str[20] = "123456";
size_t ret = s1.copy(str, 3, 2);
cout << s1 << endl;
cout << str << endl;
cout << ret << endl;
return 0;
}3.3 find和rfind的使用
find即寻找，rfind同理，倒过来寻找，也可以指定从哪里开始寻找，返回的就是找到的位置的下标，如果没有找到返回的就是npos，find可以用来找子串也可以用来寻找单个字符，这里我们试试分割后缀：
string file("string.cpp.zip");3.4 substr的使用
戛然而止，因为要分割字符串，我们还需要了解一个函数叫做substr，这个函数有利于我们分割字符串，参数两个，一个是位置，一个是长度，如果不给长度，就是默认分割到字符串结束，所以有了find返回的下标，我们这里就可以实现分割.zip：
int main()
{
string file("string.cpp.zip");
size_t pos = file.rfind('.');
string suffix = file.substr(pos);
cout << suffix << endl;
return 0;
}那么为什么我们使用rfind呢？因为有两个.，我们使用find，找到的就是第一个.，所以我们应该倒过来寻找，找到之后久交给substr就可以了。
当然，我们想要分割一段区间也是可以的：
int main()
{
string s1("I am the best");
string s = s1.substr(5, 3);
cout << s << endl;
return 0;
}
给一个区间，然后分割了3个字符，the就被分割出来了。
3.5 find_first_of(not)和find_last_of(not)的使用
首先看一下函数的参数，没有什么特殊的地方，那就随便过了？不能，因为最大的误区在它的名字这里，find_first_of，一翻译就是，找最开始的什么什么，如果这样想就大错特错辣，构造和初始化有关系吗从名字上看，丝毫没有，这个也是同理的，这个的真正用法其实是：
int main()
{
string str("Please, replace the vowels in this sentence by asterisks.");
size_t found = str.find_first_of("aeiou");
while (found != string::npos)
{
str[found] = '*';
found = str.find_first_of("aeiou", found + 1);
}
cout << str << endl;
return 0;
}这里介绍第二个重载的使用，其他的就可以类比了，这个函数的真正用法是找任意字符，即在一个字符串里面找参数中的任意字符，找到了就会返回下标，那么就可以对下标进行一些操作，比如修改，找到了也要记得修改找的位置。
last同理，只是last是从字符串末尾开始查找的，实际使用没啥区别：
void SplitFilename(const std::string& str)
{
std::cout << "Splitting: " << str << '\n';
std::size_t found = str.find_last_of("/\\");
std::cout << " path: " << str.substr(0, found) << '\n';
std::cout << " file: " << str.substr(found + 1) << '\n';
}
int main()
{
std::string str1("/usr/bin/man");
std::string str2("c:\\windows\\winhelp.exe");
SplitFilename(str1);
SplitFilename(str2);
return 0;
}只是根据不同的需求使用不同的函数罢了，比如我要分割一个网站，从末尾开始分割就可以了。
not的使用就不介绍了，有了前面两个函数的使用，这个看看也就会了。
3.6 compare的使用
compare的使用是字典序的比较，和strcmp是一样的，别看它参数多，比较我们使用第一个就可以了，其他重载要是一定要使用，看看文档也就会了：
int main()
{
string s1("123456");
string s2("321654");
cout << s1.compare(s2) << endl;
return 0;
}int main()
{
string s1("123456");
string s2("321654");
cout << (s1 < s2) << endl;
return 0;
}但是比较不仅可以用compare哦，还可以使用重载后的< >，就和cout能打印自定义类型一样。
4 Non-member function overloads部分
这部分呢就是非成员函数的部分了，重载为了全局函数，本文介绍operator+，operator>> ，operator<<，getline，relational operators。
4.1 operator+的使用
这个函数说来奇怪，重载为全局函数不是因为多特殊，只是为了支持某种形式，先看一般使用：
int main()
{
string s1("123456");
string s2("Hello world");
cout << s1 + s2 << endl;
cout << s1 + "xxx" << endl;
cout << "xxx" + s1 << endl;
cout << s1 + 'a' << endl;
cout << 'b' + s1 << endl;
return 0;
}
看起来也没什么奇怪的，那么特殊的原因是因为原来是想支持"xxx" + s1，但是发现重载为成员函数之后的第一个参数铁定是this指针，所以为了支持那种形式就重载成全局函数咯，当然不影响使用。
4.2 relational operators
compare的使用已经使用过了重载后的<，这里深入一点，我们看到相关的重载有很多个，实际上就是进行比较的，类比于日期类的多个比较，这里我们结合日期类的写法也就好理解了，当然，比较都是按照字典序进行比较的。
int main ()
{
std::string foo = "alpha";
std::string bar = "beta";
if (foo==bar) std::cout << "foo and bar are equal\n";
if (foo!=bar) std::cout << "foo and bar are not equal\n";
if (foo< bar) std::cout << "foo is less than bar\n";
if (foo> bar) std::cout << "foo is greater than bar\n";
if (foo<=bar) std::cout << "foo is less than or equal to bar\n";
if (foo>=bar) std::cout << "foo is greater than or equal to bar\n";
return 0;
}4.3 operator<< 和 operator>>的使用
这个就太简单辣：
int main()
{
string s1("123456");
cout << s1 << endl;
return 0;
}直接就过了。
4.4 getline的使用
我们先上一个实际例子：
int main()
{
string s1;
cin >> s1;
cout << s1 << endl;
return 0;
}
原本程序的意思是输入123 asd并进行打印的，但是>>重载了并不会打印完，这是因为空格，换行对于字符串的读取来说都是结束标志：
int main()
{
string s1;
cin >> s1;
while (1)
{
cin >> s1;
cout << s1 << endl;
}
return 0;
}
这样就会更形象了，那么怎么结束这个程序呢？有两种方法，一种是ctrl + c，暴力杀进程，直接结束，第二种是ctrl + z。
回归正题，我们想要读取空格怎么办？
这里就需要用到getline了：
int main()
{
string s2;
getline(cin, s2);
cout << s2 << endl;
return 0;
}
这是第二个函数的重载，第一个的最后一个参数就是让你自己设置结束标志，有兴趣可以自己试试。
5 补充函数
对于string的学习不免遇到大数运算，这里提供一个函数，to_string和stoi，分别是整型转字符串，字符串转整型，但是不要用在大数运算上面，只能是说有一点点关系：
int main()
{
string s2("111111");
int ret1 = stoi(s2);
cout << ret1 << endl;
int ret2 = 112345648;
string s3 = to_string(ret2);
cout << s3 << endl;
return 0;
}相关的文档就不上图了，有兴趣自己看看。
6 有关编码
编码是一种文字的映射，最基本的是ASCII编码，这是美国科学家研究的，最初用来存储他们的相关语言，最特殊的就是$，这个是ASCII一个标志性符号：
那么就引入了一个问题，全世界的文字那么多，不同的语言几千种甚至上万，该如何存储呢？更不用说汉字常见的就有几千个，所以汉字加起来是近9万了，如果在计算机上表达自己的语言成为了一个难题：
int main()
{
string s1("计算机");
string s2("123456");
return 0;
}
当我们存入了这样的字符串，我们在内存能看到计算机吗？
为什么会是？，编译器是如何打印计算机三个字的？这里我们不得不佩服计算机科学家们，引入了一个种新编码，叫做Unicode，称为万国码，发明出来就是为了保证计算机能打印绝大多数国家的语言的：
那么一台计算想要保证能打印不同的语言只靠一个ASCII可不够，所以引入了utf8编码，可以理解为utf8包含了Unicode和ASCIIm，与此同时还有utf16，utf32：
可以看到utf8通过一个字节的开头判断这个字属于哪个字节范围，所以计算打印的时候实际上是按照编码表去寻找最后打印的，那么16和32因为存储的成本变高了，所以不太推荐使用，目前很多机器都是使用的utf8，vs和Linux环境下使用的都是utf8。
那可能会问了，和string有什么关系？string是字符的集合：
看到这个basic了吗？我们学习的都是1个字节的字符串集合，通过编码的介绍不难猜出字符不止只有一个字节，比如：
还存在这种宽字节的字符，这就是编码的意义，存储更多的字符，使得计算机成为一门共同的语言！
感谢阅读！
