从零实现 STL vector 源码解析

[] 操作符

同样提供两个重载版本，配合 assert 检查越界，保证访问安全。

6. 空间管理

reserve

预分配指定大小的空间。若新容量小于等于当前容量则不处理；否则重新分配更大内存，拷贝旧数据，释放旧内存。注意此处应比较容量而非元素个数。

resize

调整容器大小。若扩大，用默认值或指定值填充新空间；若缩小，截断尾部元素。内部可复用构造函数逻辑简化实现。

7. 插入与删除

insert

在指定位置插入元素。若空间不足需先扩容。需注意插入可能导致迭代器失效，因此函数返回新位置的迭代器供外部使用。

push_back

复用 insert 逻辑，直接在尾部插入。

erase

删除指定位置元素。将后续元素前移覆盖，更新 _finish。若删除的是最后一个元素，返回的迭代器可能失效，需接收返回值判断。

pop_back

复用 erase 逻辑，删除尾部元素。

8. 析构函数

清理动态分配的内存，并将指针置空，防止悬垂指针。

完整代码实现

#include <iostream>
#include <cassert>
#include <algorithm>
using namespace std;

namespace bea {
template<class T>
class vector {
    typedef T* iterator;
    typedef const T* const_iterator;
public:
    // 空构造
    vector() {}

    // n 个元素初始化
    vector(size_t n, const T& val = T()) {
        _start = new T[n + 5];
        for (size_t i = 0; i < n; i++) {
            _start[i] = val;
        }
        _finish = _start + n;
        _endofstorage = _start + n + 4;
    }

    // 迭代器区间初始化
    template<class InputIterator>
    vector(InputIterator first, InputIterator last) {
        size_t n = last - first;
        _start = new T[n + 5];
        InputIterator it1 = first, it2 = _start;
        while (it1 < last) {
            *it2 = *it1;
            it1++, it2++;
        }
        _finish = _start + n;
        _endofstorage = _start + n + 4;
    }

    // 拷贝构造函数
    vector(const vector& x) {
        size_t sz = x.size();
        _start = new T[sz + 5];
        for (size_t i = 0; i < sz; i++) {
            _start[i] = x._start[i];
        }
        _finish = _start + sz;
        _endofstorage = _start + sz + 4;
    }

    // size 函数
    size_t size() const {
        return _finish - _start;
    }

    // capacity 函数
    size_t capacity() const {
        return _endofstorage - _start + 1;
    }

    // begin 函数
    iterator begin() { return _start; }
    const_iterator begin() const { return _start; }

    // end 函数
    iterator end() { return _finish; }
    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];
    }

    // 交换函数
    void swap(vector& x) {
        std::swap(x._start, _start);
        std::swap(x._finish, _finish);
        std::swap(x._endofstorage, _endofstorage);
    }

    // 赋值运算符重载
    vector& operator=(const vector x) {
        swap(x);
        return *this;
    }

    // reserve 函数
    void reserve(size_t n) {
        if (n <= capacity()) return;
        iterator tmp = new T[n + 5];
        if (_start) {
            for (size_t i = 0; i < size(); i++) {
                tmp[i] = _start[i];
            }
            delete[] _start;
        }
        _finish = tmp + size();
        _start = tmp;
        _endofstorage = tmp + n + 4;
    }

    // insert 函数
    iterator insert(iterator pos, const T& val) {
        assert(pos <= _finish);
        int n = pos - _start;
        if (capacity() < size() + 1) {
            reserve(size() + 5);
        }
        pos = _start + n;
        iterator end = _finish - 1, next = _finish;
        while (next > pos) {
            *next = *end;
            end--, next--;
        }
        *pos = val;
        _finish++;
        return pos;
    }

    void push_back(const T& val) {
        insert(_finish, val);
    }

    void resize(size_t n, T& val = T()) {
        vector(n, val);
    }

    // erase 函数
    iterator erase(iterator pos) {
        assert(pos < _finish);
        iterator end = pos + 1, front = pos;
        while (end < _finish) {
            *front = *end;
            front++, end++;
        }
        _finish--;
        return _finish;
    }

    // pop_back 函数
    void pop_back() {
        erase(_finish - 1);
    }

    // 析构函数
    ~vector() {
        delete[] _start;
        _start = nullptr;
        _finish = nullptr;
        _endofstorage = nullptr;
    }

private:
    iterator _start = nullptr;
    iterator _finish = nullptr;
    iterator _endofstorage = nullptr;
};
}

结语

通过上述实现，我们不仅掌握了 vector 的基本用法，更深入理解了 C++ 内存模型、RAII 机制及模板元编程的基础应用。希望这篇教程能帮助你夯实底层基础，写出更高效、安全的代码。