Vector 底层实现：三个指针、内存与迭代器失效

赋值运算符用了 copy-and-swap 惯用法，简洁而且异常安全。

迭代器

vector 的迭代器就是原始指针，所以直接返回就行：

iterator begin() { return _start; }
iterator end() { return _finish; } // 注意返回 finish 而非 endofstorage

const_iterator begin() const { return _start; }
const_iterator end() const { return _finish; }

反向迭代器基于正向迭代器推导，rbegin() 对应 end()-1，rend() 对应 begin()-1。

空间操作：reserve 与 resize 的坑

size() 和 capacity() 就是简单的指针差，empty() 判断两个指针是否相等。

size_t size() const { return _finish - _start; }
size_t capacity() const { return _endofstorage - _start; }
bool empty() const { return _start == _finish; }

重点在 resize 和 reserve。reserve 只改容量，不改有效元素个数；resize 既可能填充新元素也可能截断，会影响 size()。

void resize(size_t n, T val = T()) {
    if (n > size()) {
        reserve(n); // 如果新大小超过容量，先扩容
        while (_finish != _start + n) {
            *_finish = val;
            ++_finish;
        }
    } else {
        // 缩容：直接截断有效数据
        _finish = _start + n;
    }
}

void reserve(size_t n) {
    if (n > capacity()) {
        auto oldsize = size();
        iterator tmp = new T[n];

        // 关键细节：避免 memcpy 导致的浅拷贝问题
        if (_start) {
            for (size_t i = 0; i < oldsize; ++i) {
                tmp[i] = _start[i];
            }
            delete[] _start;
        }

        _start = tmp;
        _finish = _start + oldsize;
        _endofstorage = _start + n;
    }
}

别用 memcpy 拷贝对象

扩容时用 memcpy 搬运旧数据是个经典错误。memcpy 是单纯的字节拷贝，不调用拷贝构造函数。如果 T 是自定义类型且内部持有资源，源对象和副本会指向同一块内存，析构时两次 delete 导致崩溃。所以必须用循环赋值逐个初始化，调用 T 的 operator=，保证正确递归复制。

元素访问与修改

下标访问直接解引用，加个断言防越界：

const T& operator[](size_t i) {
    assert(i < size());
    return _start[i];
}

const T& operator[](size_t i) const {
    assert(i < size());
    return _start[i];
}

插入和删除是重头戏。

void push_back(const T& x) {
    if (_finish == _endofstorage) {
        reserve(capacity() == 0 ? 4 : 2 * capacity());
    }
    *_finish = x;
    ++_finish;
}

void pop_back() {
    assert(!empty());
    --_finish;
}

iterator insert(iterator pos, const T& x) {
    assert(pos <= _finish && pos >= _start);

    if (_finish == _endofstorage) {
        reserve(capacity() == 0 ? 4 : 2 * capacity());
        // 扩容后 _start 变了，pos 必须根据相对偏移重新计算，否则就是野指针
        pos = _start + (pos - _start);
    }

    iterator end = _finish;
    while (end >= pos) {
        *(end + 1) = *end;
        --end;
    }
    *pos = x;
    ++_finish;
    return pos;
}

iterator erase(iterator pos) {
    assert(pos <= _finish && pos >= _start);
    if (!empty()) {
        iterator it = pos;
        while (it < _finish) {
            *it = *(it + 1);
            ++it;
        }
        --_finish;
    }
    return pos;
}

在 insert 扩容后更新 pos 这一步很容易忘，忘了就是未定义行为。

迭代器失效：何时变野指针

vector 的迭代器就是原生指针，这带来了高效，也带来了脆弱。失效主要两种情况：

1. 空间重新分配：push_back、insert 等操作触发了扩容，_start 变了，之前获取的所有迭代器全部变成野指针。
2. 元素移动：insert 或 erase 导致 pos 后面的元素整体前移或后移，pos 及其后的迭代器虽然可能还指向合法空间，但位置含义已改变，通常也视作失效。

所以，遍历 vector 的同时不要插入或删除元素。如果实在需要，用索引循环，并在每次修改后重新计算索引；或者使用返回值更新迭代器（比如 it = v.insert(it, val) 然后 ++it）。

小结

手动写一次 vector 花不了多少时间，但能逼你直面 C++ 内存管理的细节：三个指针如何配合，深拷贝的意义，迭代器为何会失效。这些对日常使用标准 vector 同样有好处——至少 debug 时不会一脸懵。