MyVector模拟实现

重要说明

vector 是模板类，Linux 下无法纯分 .h/.cpp（模板分离编译会报错），因此实现放在头文件中，这是 C++ 模板的标准写法。

1.h文件

cpp 复制代码

#ifndef MY_VECTOR_H
#define MY_VECTOR_H

#include <cstddef>
#include <cassert>
#include <utility>
#include <initializer_list>
#include <algorithm>

// 命名空间封装，避免冲突
namespace my_stl
{
    template <class T>
    class vector
    {
    public:
        // 迭代器类型定义（原生指针）
        using value_type      = T;
        using pointer         = T*;
        using const_pointer   = const T*;
        using reference       = T&;
        using const_reference = const T&;
        using iterator        = T*;
        using const_iterator  = const T*;
        using size_type       = size_t;
        using difference_type = ptrdiff_t;

        // ========================= 构造与析构 =========================
        // 默认构造
        vector()
            : _start(nullptr)
            , _finish(nullptr)
            , _end_of_storage(nullptr)
        {}

        // 构造 n 个值为 val 的元素
        explicit vector(size_type n, const T& val = T())
            : _start(nullptr)
            , _finish(nullptr)
            , _end_of_storage(nullptr)
        {
            reserve(n);
            for (size_type i = 0; i < n; ++i)
            {
                push_back(val);
            }
        }

        // 迭代器区间构造
        template <class InputIterator>
        vector(InputIterator first, InputIterator last)
            : _start(nullptr)
            , _finish(nullptr)
            , _end_of_storage(nullptr)
        {
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }

        // 初始化列表构造 (C++11)
        vector(std::initializer_list<T> il)
            : vector(il.begin(), il.end())
        {}

        // 拷贝构造（深拷贝）
        vector(const vector& v)
            : _start(nullptr)
            , _finish(nullptr)
            , _end_of_storage(nullptr)
        {
            // 开辟新空间
            pointer tmp = new T[v.capacity()];
            // 拷贝元素
            for (size_type i = 0; i < v.size(); ++i)
            {
                tmp[i] = v._start[i];
            }

            _start = tmp;
            _finish = _start + v.size();
            _end_of_storage = _start + v.capacity();
        }

        // 赋值重载（现代写法：拷贝交换，异常安全）
        vector& operator=(vector v)
        {
            swap(v);
            return *this;
        }

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

        // ========================= 迭代器 =========================
        iterator begin() { return _start; }
        iterator end() { return _finish; }
        const_iterator begin() const { return _start; }
        const_iterator end() const { return _finish; }
        const_iterator cbegin() const { return _start; }
        const_iterator cend() const { return _finish; }

        // ========================= 容量操作 =========================
        size_type size() const { return _finish - _start; }
        size_type capacity() const { return _end_of_storage - _start; }
        bool empty() const { return _start == _finish; }

        // 扩容：只扩不缩，开辟新空间+拷贝+释放旧空间
        void reserve(size_type new_capacity)
        {
            if (new_capacity > capacity())
            {
                size_type old_size = size();
                // 申请新空间
                pointer new_start = new T[new_capacity];
                // 拷贝旧数据（深拷贝）
                for (size_type i = 0; i < old_size; ++i)
                {
                    new_start[i] = _start[i];
                }
                // 释放旧空间
                delete[] _start;

                // 更新指针
                _start = new_start;
                _finish = _start + old_size;
                _end_of_storage = _start + new_capacity;
            }
        }

        // 调整大小
        void resize(size_type new_size, const T& val = T())
        {
            if (new_size < size())
            {
                _finish = _start + new_size;
            }
            else
            {
                reserve(new_size);
                while (_finish < _start + new_size)
                {
                    *_finish++ = val;
                }
            }
        }

        // ========================= 元素访问 =========================
        reference operator[](size_type pos)
        {
            assert(pos < size());
            return _start[pos];
        }

        const_reference operator[](size_type pos) const
        {
            assert(pos < size());
            return _start[pos];
        }

        // 带越界检查
        reference at(size_type pos)
        {
            if (pos >= size())
            {
                throw std::out_of_range("vector out of range");
            }
            return _start[pos];
        }

        const_reference at(size_type pos) const
        {
            if (pos >= size())
            {
                throw std::out_of_range("vector out of range");
            }
            return _start[pos];
        }

        reference front() { return *_start; }
        const_reference front() const { return *_start; }
        reference back() { return *(_finish - 1); }
        const_reference back() const { return *(_finish - 1); }
        pointer data() { return _start; }
        const_pointer data() const { return _start; }

        // ========================= 修改操作 =========================
        // 尾插
        void push_back(const T& val)
        {
            if (_finish == _end_of_storage)
            {
                // 扩容规则：空则4，否则2倍
                reserve(capacity() == 0 ? 4 : capacity() * 2);
            }
            *_finish++ = val;
        }

        // 原位构造 (C++11) 效率更高
        template <class... Args>
        void emplace_back(Args&&... args)
        {
            if (_finish == _end_of_storage)
            {
                reserve(capacity() == 0 ? 4 : capacity() * 2);
            }
            // 直接在容器内构造，避免拷贝
            new (_finish) T(std::forward<Args>(args)...);
            ++_finish;
        }

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

        // 插入（处理迭代器失效）
        iterator insert(iterator pos, const T& val)
        {
            assert(pos >= _start && pos <= _finish);
            // 记录偏移量，解决扩容迭代器失效
            size_type len = pos - _start;

            if (_finish == _end_of_storage)
            {
                reserve(capacity() == 0 ? 4 : capacity() * 2);
            }

            // 扩容后更新迭代器位置
            pos = _start + len;
            // 元素后移
            for (iterator it = _finish; it > pos; --it)
            {
                *it = *(it - 1);
            }

            *pos = val;
            ++_finish;
            return pos;
        }

        // 删除（处理迭代器失效）
        iterator erase(iterator pos)
        {
            assert(pos >= _start && pos < _finish);
            // 元素前移
            for (iterator it = pos; it < _finish - 1; ++it)
            {
                *it = *(it + 1);
            }
            --_finish;
            return pos;
        }

        // 清空元素（不释放空间）
        void clear()
        {
            _finish = _start;
        }

        // 交换两个 vector
        void swap(vector& v)
        {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_end_of_storage, v._end_of_storage);
        }

    private:
        pointer _start;          // 数组起始
        pointer _finish;         // 有效元素末尾
        pointer _end_of_storage; // 容量末尾
    };

    // 全局 swap 重载
    template <class T>
    void swap(vector<T>& v1, vector<T>& v2)
    {
        v1.swap(v2);
    }
}

#endif // MY_VECTOR_H

2.main.cpp文件

cpp 复制代码

#include <iostream>
#include "my_vector.h"
using namespace std;

// 测试函数
void test_vector()
{
    cout << "===== 测试 my_vector =====" << endl;

    // 1. 默认构造 + 尾插
    my_stl::vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.emplace_back(40); // C++11 原位构造
    cout << "v1: ";
    for (auto e : v1) cout << e << " ";
    cout << "\nsize: " << v1.size() << " capacity: " << v1.capacity() << endl;

    // 2. 初始化列表构造
    my_stl::vector<int> v2 = {1,2,3,4,5};
    cout << "\nv2: ";
    for (size_t i = 0; i < v2.size(); ++i) cout << v2[i] << " ";
    cout << endl;

    // 3. 拷贝构造
    my_stl::vector<int> v3 = v2;
    cout << "v3(拷贝): ";
    for (auto it = v3.begin(); it != v3.end(); ++it) cout << *it << " ";
    cout << endl;

    // 4. 插入/删除
    auto it = v1.insert(v1.begin() + 1, 99);
    cout << "\n插入后 v1: ";
    for (auto e : v1) cout << e << " ";
    cout << "\n迭代器指向: " << *it << endl;

    it = v1.erase(v1.begin() + 2);
    cout << "删除后 v1: ";
    for (auto e : v1) cout << e << " ";
    cout << "\n迭代器指向: " << *it << endl;

    // 5. 容量调整
    v1.resize(6, 0);
    cout << "\nresize(6)后 v1: ";
    for (auto e : v1) cout << e << " ";
    cout << endl;

    v1.reserve(20);
    cout << "reserve(20)后 capacity: " << v1.capacity() << endl;

    // 6. 清空
    v1.clear();
    cout << "clear后 size: " << v1.size() << " capacity: " << v1.capacity() << endl;
}

// 测试自定义类型
struct Test
{
    int a;
    Test(int x = 0) :a(x) {}
};

void test_custom_type()
{
    cout << "\n===== 测试自定义类型 =====" << endl;
    my_stl::vector<Test> v;
    v.emplace_back(100);
    v.emplace_back(200);
    cout << "自定义类型: " << v[0].a << " " << v[1].a << endl;
}

int main()
{
    test_vector();
    test_custom_type();
    return 0;
}

谢谢