关于string的‘\0‘与string，vector构造特点，反迭代器与迭代器类等的讨论

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

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

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

问题四：string的流提取问题

问题五：迭代器失效

问题六：Vector 最大最小值索引位置

问题7：反迭代器的实现（包含迭代器类的介绍）

前言：

前几篇文章我们已经介绍完了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;elsecout << "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\0cout << b.capacity() << endl;cout << b.size() << endl;if (b[3] == '\0')cout << "yes" << endl;elsecout << "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;
}

运行结果：

问题7：反迭代器的实现

在上一篇文章中的list的迭代器是没有进行实现的，关于list的迭代器他的实现还是有点特殊的地方；

迭代器类存在的意义

之前模拟实现string和vector时都没有说要实现一个迭代器类，为什么实现list的时候就需要实现一个迭代器类了呢？

因为string和vector对象都将其数据存储在了一块连续的内存空间，我们通过指针进行自增、自减以及解引用等操作，就可以对相应位置的数据进行一系列操作，因此string和vector当中的迭代器就是原生指针。

然而对于list的来说，他的每个结点的存储都不是连续的，是随机的，不可以像string，vector那样仅仅通过与简单的自增，自减以及进行解引用等操作对相应的结点做操作。

而迭代器的意义就是，让使用者可以不必关心容器的底层实现，可以用简单统一的方式对容器内的数据进行访问。

既然list的结点指针的行为不满足迭代器定义，那么我们可以对这个结点指针进行封装，对结点指针的各种运算符操作进行重载，使得我们可以用和string和vector当中的迭代器一样的方式使用list当中的迭代器。就比如，当你使用list当中的迭代器进行自增操作时，实际上执行了p = p->next语句，只是你不知道而已，这一步迭代器替你进行了复杂的操作，这样就可以在各种操作上进行了统一。

总结： list迭代器类，实际上就是对结点指针进行了封装，对其各种运算符进行了重载，使得结点指针的各种行为看起来和普通指针一样。（例如，对结点指针自增就能指向下一个结点）

迭代器类的模板参数说明

查阅相关std源文件库里面的设计，发现迭代器类的模板参数的设计为3个。

template<class T, class Ref, class Ptr>

这里就引发出来思考为什么要这样设计呢？

在list的模拟实现当中，我们typedef了两个迭代器类型，普通迭代器和const迭代器。

typedef _list_iterator<T, T&, T*> iterator;
typedef _list_iterator<T, const T&, const T*> const_iterator;

这里我们就可以看出，迭代器类的模板参数列表当中的Ref和Ptr分别代表的是引用类型和指针类型

当我们使用普通迭代器时，编译器就会实例化出一个普通迭代器对象；当我们使用const迭代器时，编译器就会实例化出一个const迭代器对象。

若该迭代器类不设计三个模板参数，那么就不能很好的区分普通迭代器和const迭代器。（换句话来说，按照与string与vector的思路来写list的const与非const迭代器再使用的时候会报错，编译器不知道走那个迭代器）

那么就再前面文章的基础上加上迭代器类吧。

template <class T>
struct list_node
{T _data;list_node<T>* _prev;list_node<T>* _next;list_node(const T& x = T()):_data(x), _prev(nullptr), _next(nullptr){}
};
template<class T, class Ref, class Ptr>
struct __list_iterator 
{typedef list_node<T> Node;typedef __list_iterator<T, Ref, Ptr> self;Node* _node;		__list_iterator(Node* node):_node(node){}
}
class list
{typedef list_node<T> Node;
public:typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T,const T&,const T*> const_iterator;const_iterator begin() const{return const_iterator(_head->_next);}const_iterator end() const{return const_iterator(_head);}iterator begin(){return _head->_next;}iterator end(){return _head;}
private:Node* _head;size_t _size;
};

我们们迭代器类的构造函数就是用我们传的结点参数来进行初始化。

运算符重载需要注意要返回self就行

self是当前迭代器对象的类型：

介绍完迭代器类，下面就介绍反迭代器是怎么实现的吧；

同样反迭代器我们也需要设计一个反迭代器类；

但是反迭代器的实现由于正向迭代器实现的思路又有所不一样

其中他的成员变量是正向迭代器

大致如图所示：

template<class Iterator, class Ref, class Ptr>
class Reserve_iterator
{typedef Reserve_iterator<Iterator, Ref, Ptr> Self;public:Reserve_iterator(Iterator it):_it(it){}
private:Iterator _it;
};

同样他与正向迭代器一样，为了方便会进行typedef

rbegin与rend

rbegin是其实是返回的end，rend其实是返回的begin，弄清楚这一点就比较好说了，只需要将begin传到反迭代器类的rendend传到反迭代器类的rbegin就可以了；

reserve_iterator rbegin()
{return reserve_iterator(end());
}
reserve_iterator rend()
{return reserve_iterator(begin());
}
const_reserve_iterator rbegin() const
{return const_reserve_iterator(end());
}
const_reserve_iterator rend() const
{return const_reserve_iterator(begin());
}

operator++

对于反迭代器的++其实对应的就是正向迭代器的--

所以在实现的时候只需要进行减减就可以

	Self& operator++(){--_it;return *this;}

这里返回的是引用其实很好理解，因为这里的++产生的效果是前置++，所以直接在原来的基础上进行操作就可以，返回进行返回引用；

operator--

同样还有--，对应的也是正向迭代器的++，还是返回引用就可以

	Self& operator--(){++_it;return *this;}

这里就不一样了，一个是返回的ref一个是ptr，这是因为我们在开始的情况下，就将ref为引用，ptr为解引用。

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