目录
问题一：关于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; 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;
}运行结果：
问题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为解引用。
到这里就完了，写作不易还请点赞；
