👍作者主页：进击的1++
🤩 专栏链接：【1++的C++初阶】
文章目录
- 一，什么是vector?
- 二，构造与析构
- 三，vector迭代器的实现
- 四，vector部分重要接口的实现
一，什么是vector?
vector是一种表示大小可变数组的容器。其本质就是动态数组，与我们前面写过的顺序表是大同小异的。与其他动态序列容器相比，vector的随机访问更加高效。但是，其插入与删除由于需要移动数据的原因，就显得效率较低。接下来我们将从其基本构成，各接口的实现原理以及易发生的问题等方面进行vector的学习！
二，构造与析构
与string不同的是，string一定是字符串,而vector中却可以存储多种类型的数据。这是模板就起了很大的作用。我们暂且将其数据类型叫做T。
vector采用的数据结构非常简单，线性连续空间，它以两个迭代器start,finish分别指向已经被使用了的空间。以end_of_storage来指向整块空间的尾端。
因此，其构造函数如下：
vector()
:_start(nullptr)
,_finish(nullptr)
,end_of_storage(nullptr)
{}
讲完了构造函数，我们再来讲讲拷贝构造。
先来传统写法的构造函数。
vector(const vector<T>& v)
{
//深拷贝
_start = new T[v.capacity()];
//弊端：当有vector<vector<T>>这样的结构时，vector<T>进行的是浅拷贝。
// //memcpy(_start, v._start, sizeof(T) * v.size());
// //改
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
end_of_storage = _start + v.capacity();
}
这里需要注意的就是我们在注释中提到的，当vector中存储的数据是自定义类型涉及到空间时，如果仅仅使用memcpy，则将会出现两对象指向同一块空间。导致同一块空间被析构两次，就会报错。
在说明解决方法前，我们再补充一段代码
void swap(vector<T>& tmp)
{
std::swap(_start, tmp._start);
std::swap(_finish, tmp._finish);
std::swap(end_of_storage, tmp.end_of_storage);
}
//赋值重载
vector<T>& operator=( vector<T> v)//在传参时就进行了深拷贝
{
swap(v);
return *this;
}
有了上述补充代码，我们就可以解决出现的问题了。
解决办法就是，让vector中存储的数据也进行深拷贝，便捷的方法就是利用遍历+其自己的赋值重载（自定义类型）。这样每个vector中的数据（自定义类型）都经过深拷贝，就不会发生同一空间被析构两次的情况。
我们再来学一种用迭代器进行初始化的构造构造。
template <class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
,_finish(nullptr)
,end_of_storage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
这里的迭代器也是使用了模板，使其能够用各种类型的迭代器进行初始化。
在上面我们讲述了拷贝构造的传统写法，接下来，我们在学习一种现代写法。
vector(const vector<T>& v)
:_start(nullptr)
,_finish(nullptr)
,end_of_storage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}
其先是利用迭代器初始化构造出一个临时对象。然后将临时对象内的三个成员交换，由于其三个成员类型为迭代器（本质为T*）因此，交换就是原来tmp对象的空间，由*this维护，*this原来的空间则交给了tmp维护，并且，tmp是在函数内定义的，因此出了此函数，其生命周期结束，进行析构。**（要注意的是，在进行交换前，this对象要进行初始化，若不对其初始化，this中的成员是野指针，释放野指针指向的空间是错误的。)
最后，我们来讲一讲析构的实现----超简单的😎😎😎！
直接上代码😏😏😏
~vector()
{
delete[] _start;
_start = nullptr;
_finish = nullptr;
end_of_storage = nullptr;
}
三，vector迭代器的实现
在第二小节我们就提到过其迭代器的本质为T*指针。
其迭代器主要作用就是进行遍历。
演示如下：
void test4()
{
vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(1);
v.push_back(1);
vector<int>::iterator it = v.begin();
while (it!= v.end())
{
cout << (*it) << endl;
++it;
}
}
除了上述遍历方法，还有一种范围for的遍历方法，其底层的实现就是用的迭代器。演示如下：
void test4()
{
vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(1);
v.push_back(1);
for (auto e : v)
{
cout << e << " ";
}
cout <<endl;
}
四，vector部分重要接口的实现
reserve的实现
void reserve(size_t n)
{
size_t sz = size();
if (n > capacity())
{
iterator tmp = new T[n];
if (_start)
{
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[]_start;
}
_start = tmp;
_finish = _start + sz;
end_of_storage = _start + n;
}
}
在文章【1++的C++初阶】之内存管理中，我们有说过new，delete与malloc,free等的一个区别就是，前者能够自动调用构造与析构函数，因此我们在申请空间或者是扩容时，选择用new。当用new进行间接的扩容时，就涉及到了数据的拷贝，解决方法与拷贝构造相同。
resize的实现
void resize(size_t n, T val = T())
{
if (n > capacity())
{
reserve(n);
}
if (n > size() )
{
while(_finish<_start+n)
{
*_finish = val;
++_finish;
}
}
else
{
_finish = _start + n;
}
}
resize是调整其容器的大小，当其大小大于开辟空间的大小时，就进行扩容；并且，其还具有初始的功能。
insert实现
iterator insert(iterator pos, T val)
{
size_t len = pos - _start;
assert(pos >= begin() && pos <= end());
//扩容
if (end_of_storage == _finish)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
//更新pos
pos = _start + len;
//移动数据
iterator end = _finish-1;
while ( end>= pos)
{
*(end + 1) = *end;
end--;
}
*pos = val;
_finish++;
return pos;
}
insert是将数据插入到pos位置，首先就要判断pos是否合法，然后要判断空间大小是否满足。**这里要注意的是当扩容后，pos就会失效，因为pos原来指向的空间已经不是我们要的空间了，因此，要更新pos。**在插入时，由于是连续的空间，因此要进行数据的移动。返回插入位置的迭代器。
erase的实现
iterator erase(iterator pos)
{
//不考虑缩容
//移动数据
assert(pos >= _start && pos < _finish);
iterator begin = pos;
while (begin < _finish)
{
*begin = *(begin + 1);
begin++;
}
_finish--;
return pos;
}
在有些编译器下，会涉及到缩容，因此与insert一样，会面临迭代器失效的问题，因此要更新pos,但我们的实现不考虑缩容的情况。erase原理与insert相似，都要进行数据的挪动。
