介绍
1. 本质与存储结构
- 动态数组实现 ：vector 本质是动态分配的数组，采用连续内存空间存储元素，支持下标访问（如
vec[i]），访问效率与普通数组一致（时间复杂度 O (1)）。 - 动态扩容机制 ：当元素数量超过当前容量时，vector 会重新分配更大的内存空间，将原元素复制到新空间。为避免频繁扩容，其扩容策略通常为对数增长（如每次容量翻倍），确保末尾插入元素的均摊时间复杂度为 O (1)。
2. 空间分配策略
- 预分配额外空间：vector 会分配比实际需求更大的存储空间，以减少扩容次数。例如，初始容量为 n 时，插入新元素可能直接扩容至 2n，而非每次只增加 1 个元素的空间。
- 空间与效率的权衡：预分配策略虽增加了初始存储空间占用，但避免了频繁内存重分配的开销（如复制元素的耗时），在动态增长场景下更高效。
3. 与其他序列容器的差异
- 与 deque 的对比 ：
- deque 两端插入 / 删除效率更高（vector 仅末尾高效），且支持动态扩容（但内存非连续，需维护分段数组）。
- 与 list/forward_list 的对比 ：
- list/forward_list 为双向链表 / 单向链表，内存不连续，不支持下标访问，但任意位置插入 / 删除效率更高（无需移动元素）。
- vector 的迭代器和引用更稳定（连续内存保证迭代器不会因中间元素删除而失效，除非操作涉及扩容）。
4. 适用场景与注意事项
- 适用场景 ：
- 需要频繁通过下标访问元素（如数组场景）。
- 主要在末尾进行插入 / 删除操作（如栈、队列场景）。
- 注意事项 ：
- 非末尾插入 / 删除操作（如中间位置插入）会导致元素移动，效率较低，此时优先选择 list。
- 若已知数据量大小，可使用
reserve(n)预分配空间，避免多次扩容。 - 扩容会导致原有迭代器、指针、引用失效（因内存地址变更），需重新获取。
实现
基本结构
在我们的vector的实现中，迭代器部分不需要特殊处理，它只是一个普通的指针，只是typedef的结果。
cpp
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};这就是vector的基本结构，有三个指针，分别指向vecotr的开始位置，元素最后的插入位置以及该空间结束位置。
迭代器
因为vector的迭代器很质朴，就是一个指针，所以他的实现也非常简单，不需要进行++、--运算符重载操作，只需要写出const迭代器和普通迭代器，其实就是用const对指针修饰一下，代码如下：
cpp
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
cpp
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}size与capacity
实现size与capacity就是用指针进行相减
cpp
size_t capacity() const
{
return _endofstorage - _start;
}
size_t size() const
{
return _finish - _start;
}reserve
reserve是预先分配指定大小的内存空间，以避免后续插入元素时频繁触发动态扩容，从而提高性能。
- 注意 ：
reserve仅改变容量，不改变容器的大小（size()），也不初始化元素。
实现 ：若 n 大于当前容器的容量（capacity()），则重新分配内存，使容量至少为 n，然后将原来的数据拷贝到新开的空间中，完成操作后，再将_start指向新开的空间；否则不做任何操作。
cpp
void reserve(size_t n)
{
if (n > capacity())
{
T* tmp = new T[n];
size_t sz = size();
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * sz);
for (size_t i = 0; i < sz; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}resize
- 若
n > size()，容器扩容并插入新元素。 - 若
n < size()，容器收缩并删除尾部元素。 - 若
n == size()，不做任何操作。
下面将<=合并起来。
cpp
void resize(size_t n, const T& val = T())
{
if (n <= size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
}insert
首先先用assert判断传入的迭代器位置是否合理，不合理直接报错，若合理，看_finsh和_endofstorage是否相等，若相等则说明需要扩容。扩容时，需要重新更新一下传入迭代器的位置，因为扩容后位置发生了变化。
之后进行从后往前挪动数据，切记，一定是从后往前！！！
cpp
void insert(iterator pos, const T& x)
{
assert(pos >= _start);
assert(pos <= _finish);
if (_finish == _endofstorage)
{
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
}从实现我们也可以看出，insert是比较消耗时间的。
push_back
有了insert，那么push_back的实现就非常简单了，直接复用就可以了。
cpp
void push_back(const T& x)
{/*
if (_finish == _endofstorage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = x;
++_finish;*/
insert(end(), x);
}erase
类似于insert，就不多解释。
cpp
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos + 1;
while (it < _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}构造函数
vector的构造方法是很多的，我直接分享给大家，原理都很简单
cpp
vector()
{
}
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
// v2(v1)
vector(const vector<T>& v)
{
reserve(v.capacity());
for (auto& e : v)
{
push_back(e);
}
}