关于string的‘\0‘与string，vector构造特点加部分特别知识点的讨论

目录

前言：

问题一：关于string的''\0''问题讨论

问题二：C++标准库中的string内存是分配在堆上面吗？

问题三：string与vector的capacity大小设计的特点

问题四：string的流提取问题

问题五：迭代器失效

 问题六：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，那么就会报错。

注意：

1. vs 对于迭代器失效检查很严格，如使用了 erase 之后，之前的迭代器就不允许使用，只有重新给迭代器赋值，才可以继续使用
2. 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;
}

运行结果：

到这里就完了，写作不易还请点赞；