介绍
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的结果。
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对指针修饰一下，代码如下：
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;} 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就是用指针进行相减
size_t capacity() const{return _endofstorage - _start;}size_t size() const{return _finish - _start;}
reserve
reserve是预先分配指定大小的内存空间，以避免后续插入元素时频繁触发动态扩容，从而提高性能。
- 注意：
reserve仅改变容量，不改变容器的大小（size()），也不初始化元素。
实现：若 n 大于当前容器的容量（capacity()），则重新分配内存，使容量至少为 n，然后将原来的数据拷贝到新开的空间中，完成操作后，再将_start指向新开的空间；否则不做任何操作。
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()，不做任何操作。
下面将<=合并起来。
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是否相等，若相等则说明需要扩容。扩容时，需要重新更新一下传入迭代器的位置，因为扩容后位置发生了变化。
之后进行从后往前挪动数据，切记，一定是从后往前！！！
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的实现就非常简单了，直接复用就可以了。
void push_back(const T& x){/*if (_finish == _endofstorage){reserve(capacity() == 0 ? 4 : capacity() * 2);}*_finish = x;++_finish;*/insert(end(), x);}erase
类似于insert，就不多解释。
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的构造方法是很多的，我直接分享给大家，原理都很简单
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);}}
入门项目推荐)
