目录
问题三：string与vector的capacity大小设计的特点
[问题六：Vector 最大 最小值 索引 位置](#问题六：Vector 最大 最小值 索引 位置)
前言：
前几篇文章我们已经介绍完了string，vector，list的使用与string的使用原理，但是仅仅知道这些对于我们日常使用来说已经够了，但是在我们日常使用的时候，不免会有报错与相关的疑惑，那么这里我介绍几个我认为有问题的地方，后续有问题的话，还会继续补充。
问题一：关于string的''\0''问题讨论
之前在某篇文章中看到，C语言字符串是以'\0'结尾的，但是C++string类型的字符串并不是以'\0'结尾。话不多说，直接放代码（vsX86环境）：
#include<iostream> #include<string> using namespace std; int main() { string b("abc"); cout << b.capacity() << endl; cout << b.size() << endl; if (b[3] == '\0') cout << "yes" << endl; else cout << "no" << endl; return 0; }运行结果：
.
可以看到我们创建的这个string，他的容器大小为15，这个string存储大小为3，但是我们却可以通过越界访问 b[3] ， 并且通过验证字符串的结尾就是'\0'。此时我的内心是疑惑的，**心想"abc"是C语言风格的字符串给b构造，肯定会把"abc"后面影藏的'\0'给构造进去，**如果不会这样就会在迭代器里面不会遇见结束表示符。那么至于这里的结尾的最后一个'\0'，从结果来说是大小size不计算的，所以大小size是3。
但是我们又尝试别的构造的话又会尝试别的疑惑，比如这个代码：
#include<iostream>
#include<string>
using namespace std;
int main()
{
string b("abcd",3);//这种构造方法是通过字符串abcd，然后只取前3个字符进行构造string
//但是这个字符串存放的其实是 abcd\0
cout << b.capacity() << endl;
cout << b.size() << endl;
if (b[3] == '\0')
cout << "yes" << endl;
else
cout << "no" << endl;
return 0;
}
结果跟上面一模一样。此刻我又想，构造函数会在末尾自动添加一个'\0'，并且size和capacity函数都不计算'\0'的。
但是我们一开始是假设他跟c语言的风格相似的会把abc后面的'\0'会自动添加上，但是我们这个代码是只取了abcd\0这个字符串的前三个，没有'\0'啊~！
所以此刻，我肯定是矛盾的！！因为最开始说string字符串是不以'\0'结尾的，但是测试下来，确实是以'\0'结尾的。
哎呀~为什么呢？经过查阅资料后，才得知了其中的奥妙，奥妙如下：
std::string：标准中未明确规定需要\0作为字符串结尾。编译器在实现时既可以在结尾加\0，也可以不加。（因编译器不同，就比如vs就不用）
但是，当通过c_str()或data()（二者在 C++11 及以后是等价的）来把std::string转换为const char *时，会发现最后一个字符是\0。但是C++11，string字符串都是以'\0'结尾（这也是c++祖师爷为以前的自己的规定的优化）。
为什么C语言风格的字符串要以'\0'结尾，C++可以不要？
c语言用char*指针作为字符串时，在读取字符串时需要一个特殊字符0来标记指针的结束位置，也就是通常认为的字符串结束标记。而c++语言则是面向对象的，长度信息直接被存储在了对象的成员中，读取字符串可以直接根据这个长度来读取，所以就没必要需要结束标记了。而且结束标记也不利于读取字符串中夹杂0字符的字符串。
这里我们深入一下string的构造时的细节：
#include<iostream> #include<string> using namespace std; int main() { int aa = 0; printf("栈区的地址：%p\n", &aa); int* pl = new int; printf("堆区的地址：%p\n", pl); string a("abcddddddddddddddddddddddddd", 20); printf("a的地址: %p\n", &a); printf("a[0]的地址: %p\n", &a[0]); a[1] = 'X'; cout << a << endl; printf("a的地址: %p\n", &a); printf("a[0]的地址: %p\n", &a[0]); string b("abc"); printf("b的地址: %p\n", &b); printf("b[0]的地址: %p\n", &b[0]); return 0; }
然后通过运行的知，
用红色标注出来的是在栈上存储的，蓝色标注的时在堆上存储的，然而a，b就与指针类似，他们指向一片空间，空间内存储的对象信息， 对象地址分别是006FF6AC与006FF688,他俩的地址跟栈区地址最为接近所以该对象存储在栈区上。同理a[0]是堆区上，但是b[0]按道理也应该是在堆区上，但是为什么会是是在栈区上呢？其实这是c++的一个特殊处理，这里留下一个小疑问，（下一个问题进行解答，这里先给出为什么的答案：当string内存存储的个数在16以内（包括'\0'）（后面解释为什么是16）在栈上，超过以后在堆上。）
所以，string在构造函数的时候，会在堆上开辟一块内存存放字符串，并且指向这块字符串。
（这里给大家提问一个小问题：就是为什么a先定义的，但是a对象地址为什么比b的大？）
解答：a、b是两个局部对象变量，栈是向下增长的，所以先入栈的变量地址高，即&a > &b，
问题二：C++标准库中的string内存是分配在堆上面吗？
例如我声明一个string变量。
string str;
一直不停的str.append("xxxxx");时，str会不停的增长。我想问的是这个内存的增长，标准库中的string会把内存放置到堆上吗？
另外STL中的其他容器是否遵循相同的规则。
首先我们给出结论：16以内在栈上，超过以后在堆上。(这句话的答案省略上面的问题的前提条件：【在栈上构造的 string 对象】，如果string 是 new 出来的即在堆上构造的，当然内部的缓冲区总是在堆上的）。(vector也是如此，但是细节上略有不同）
为什么要这样做呢？
如果以动态增长来解释就是：
因为栈通常是一种具有固定大小的数据结构，如数组实现的栈在创建时会指定一个固定的容量。因此，一般情况下，栈是不支持动态增长的。
所以是存储在堆上的。
其实还有另一个原因，那么下一个问题给出解答；
问题三：string与vector的capacity大小设计的特点
在我们设计string与vector的时候，你是否观察过他的capacity的大小呢？就比如vs里面为什么会让string与vector在其存储的内存个数小于16时会将数据存储在栈上，大于16存储在堆上呢？
这是因为string与vector第一次会在栈上开辟空间，直接开辟16个单位空间，然后挨个进行流提取，这样的话就会方便很多 ，就算要再添加数据，也不需要进行动态增长，然后这个16个单位空间就是string与vector的capacity。这里的证明可以通过调试自己查看他的capacity，当然编译器不同，可能这个首次开辟空间大小略有不同，但是不影响。
总的来说这两种解释都是解决的次要问题，他这样设计主要为了解决内存碎片的问题；如果存储的内容大小小于16，他就会先存在栈上的数组里面，当大于16，就会进行拷贝到堆上，然后栈上的数组就会进行浪费，这样达到了利用空间换时间的效果
问题四：string的流提取问题
首先如果我们自己实现string的流提取，我们会下意识认为会挨个提取输入的字符，然后挨个与s进行对接，代码试下如下： （这个代码实现的流提取是完全没有问题的）
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
但是这样写会有一个弊端，就是会多次进行扩容，俗话常说：扩容本身就是一件麻烦的时，浅拷贝就不多说了，深拷贝就更麻烦了；
所以后来就进行了优化，会先开辟一个数组，然后将流提取的字符挨个放到数组里面，当数组满的时候（或者流提取的字符提取完了）我们当让s+=数组；这样既保证了存储的数据在堆上，也避免了多次进行扩容；（需要注意的是我们要自己添加 '\0' 在string的末尾）
istream& operator>>(istream& in, string& s)
{
s.clear();
char buff[129];
size_t i = 0;
char ch;
//in >> ch;
ch = in.get();
s.reserve(128);
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 128)
{
buff[i] = '\0';
s += buff;
i = 0;
}
//in >> ch;
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
当然这上面的两个问题都是存在于string于vector上的，因为他们存储的数据是连续的，二list作为链表就不存在这样的问题。
问题五：迭代器失效
然而迭代器失效就不一样了，string，vector，list都存在。
在我们使用迭代器进行遍历的时候，不免会出现不正当的使用而使其迭代器失效；
失效的主要原因就是：迭代器对应的指针所指向的空间已经被销毁了，而使用一块已经被释放的空间的时候，就会造成程序崩溃(即如果继续使用已经失效的迭代器， 程序可能会崩溃)。俗话来说就是野指针了。
前面我们都在用string来进行解释，这里我们使用vector来解释，
1
就比如下面这个代码：
include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> v(10, 1);
auto it = v.begin();
v.insert(it, 0);
(*it)++;
return 0;
}
看起来没有问题，但是我们是先给迭代器赋值，然后进行插入，但是有一点问题就是如果插入时恰好进行扩容，并且时异地扩容，那么这个it就会变为野指针。从而达到迭代器失效的问题。
2
同样插入存在异地扩容，当然删除也存在着迭代器失效的问题；
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> v(10, 1);
auto it = v.end() - 1;
v.erase(it);
(*it)++;
return 0;
}
这时候如果再进行使用it，那么就会报错。
注意：
- vs 对于迭代器失效检查很严格，如使用了 erase 之后，之前的迭代器就不允许使用，只有重新给迭代器赋值，才可以继续使用
- Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。
问题六：Vector 最大 最小值 索引 位置
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<double> v{ 1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0, 3.0, 4.0, 5.0 };
vector<double>::iterator biggest = max_element(begin(v), end(v));
cout << "Max element is " << *biggest << " at position " << distance(begin(v), biggest) << endl;
auto smallest = min_element(begin(v), end(v));
cout << "min element is " << *smallest << " at position " << distance(begin(v), smallest) << endl;
return 0;
}
运行结果：
到这里就完了，写作不易还请点赞；
