🌟 快来参与讨论💬，点赞👍、收藏⭐、分享📤，共创活力社区。🌟

如果你对string，vector还存在疑惑，欢迎阅读我之前的作品 ： 

之前文章🔥🔥🔥 【C++】vector 类深度解析：探索动态数组的奥秘

               🔥🔥🔥 【C++】string 类深度解析：探秘字符串操作的核心

---

目录

一、引言🎉

二、vector 类的功能需求分析👀

（一）存储元素数据📦

（二）元素访问与修改✍️

（三）元素数量相关操作📏

（四）迭代器支持🔍

（五）内存管理🧹

三、模拟实现的关键步骤和代码解析💻

（一）类的定义🎯

（二）构造函数实现🔨

（三）析构函数实现🚮

（四）获取元素数量和容量函数📏

（五）判断是否为空函数🤔

（六）预留空间函数📦

（七）调整大小函数📏

（八）下标操作符重载🎯

（九）赋值操作符重载✍️

（十）添加和删除元素函数🎯

（十一）迭代器相关函数🔍

四、总结😎

---

一、引言🎉

在 C++ 的编程世界里，动态数组就像一个神奇的魔法盒子🎁，可以根据我们的需求灵活地改变大小。而标准库中的 vector 类，就是这个魔法盒子的绝佳实现者🧙‍♂️！它为我们提供了超级方便的操作接口，让我们能够轻松地处理各种动态数据存储和操作的任务。你是不是也像我一样，对 vector 类的内部实现充满了好奇呢😏？

嘿嘿，那就跟着我一起踏上模拟实现 vector 类的奇妙之旅吧🚀！ 

---

二、vector 类的功能需求分析👀

（一）存储元素数据📦

我们希望 vector 类能够像一个智能的容器一样🧺，用连续的内存空间来存放元素。这样的话，就可以像在一排整齐排列的小格子里找东西一样，通过索引快速地访问到任何一个元素😃，是不是很方便呢🧐？而且哦，它还要能自动调整存储空间的大小，就像一个会伸缩的魔法口袋👝，当我们添加或删除元素的时候，它能够自动适应，不会让内存出现浪费或者不够用的情况，是不是超级厉害😎！

（二）元素访问与修改✍️

1. 当然啦，我们需要能够轻松地通过索引来获取元素的值，就像打开小格子拿东西一样简单😏。而且，我们还希望能够修改这个元素的值，让我们可以随心所欲地更新数据😎。
2. 有时候，我们想要在指定的位置插入一个新元素，这就好比在排队的人群中突然插入一个小伙伴👫，vector 类要能够巧妙地把后面的元素都往后挪一挪，给新元素腾出空间哦😃。
3. 还有还有，当我们想要删除某个位置的元素时，vector 类要能像变魔术一样，把后面的元素都往前移一移，填补上这个空缺，保持队伍的整齐有序😎。

（三）元素数量相关操作📏

1. 我们得知道 vector 里面到底装了多少个元素呀，这样才能更好地控制和处理数据😉。所以，需要有一个方法来获取元素的数量。
2. 当我们预先知道大概要存储多少个元素的时候，希望能够提前告诉 vector 类，让它提前准备好足够的空间，就像告诉魔法口袋我们大概要装多少东西一样，这样可以提高效率哦😎。

（四）迭代器支持🔍

为了能够方便地遍历 vector 中的元素，我们需要 vector 类提供迭代器。迭代器就像是一个小导游👨‍✈️，可以带着我们逐个访问 vector 中的元素，让遍历操作变得轻松愉快😃。

（五）内存管理🧹

最后但同样重要的是，vector 类要能够合理地管理内存。它要知道什么时候该申请新的内存，什么时候该释放不再使用的内存，就像一个勤劳的小管家一样，把内存管理得井井有条，避免内存泄漏和浪费，确保我们的程序能够高效稳定地运行😎。

---

三、模拟实现的关键步骤和代码解析💻

（一）类的定义🎯

template<typename T>
class MyVector {
private:
    T* data;           // 存储元素的数组指针
    size_t size_;      // 当前元素数量
    size_t capacity_;  // 数组容量

public:
    MyVector();                            // 默认构造函数
    MyVector(size_t n, const T& value = T());  // 构造函数，初始化n个相同元素
    MyVector(const MyVector<T>& other);     // 拷贝构造函数
    ~MyVector();                           // 析构函数

    size_t size() const;                    // 获取元素数量
    size_t capacity() const;                // 获取数组容量
    bool empty() const;                     // 判断是否为空
    void reserve(size_t new_capacity);      // 预留空间
    void resize(size_t new_size, T value = T());  // 调整大小

    T& operator[](size_t index);            // 下标操作符重载（非const版本）
    const T& operator[](size_t index) const;  // 下标操作符重载（const版本）
    MyVector<T>& operator=(const MyVector<T>& other);  // 赋值操作符重载

    void push_back(const T& value);         // 在末尾添加元素
    void pop_back();                        // 删除末尾元素
    void insert(size_t pos, const T& value);  // 在指定位置插入元素
    void erase(size_t pos);                 // 删除指定位置元素

    typedef T* iterator;                    // 迭代器类型定义
    iterator begin();                       // 返回起始迭代器
    iterator end();                         // 返回结束迭代器
};

 👇解释：

这里我们定义了一个模板类MyVector，它可以存储任意类型的元素哦😎。有一个指针data用来指向存储元素的数组，size_记录当前元素的数量，capacity_表示数组的容量。然后还有各种各样的函数，它们就像一群小助手，分别负责不同的操作任务呢😉。

 

（二）构造函数实现🔨

1. 默认构造函数

template<typename T>
MyVector<T>::MyVector() : data(nullptr), size_(0), capacity_(0) {}

😃这个默认构造函数超级简单，就像创建一个空的魔法口袋一样，把data指针设为nullptr，表示还没有分配内存，元素数量size_和容量capacity_都初始化为 0😎。
2. 指定大小和初始值的构造函数

template<typename T>
MyVector<T>::MyVector(size_t n, const T& value) : size_(n), capacity_(n) {
    data = new T[capacity_];
    for (size_t i = 0; i < size_; ++i) {
        data[i] = value;
    }
}

👀这个构造函数就像是按照我们的要求定制魔法口袋的大小和初始物品一样🧐。我们告诉它要创建一个能装n个元素的 vector，并且每个元素都初始化为value。它先分配足够的内存空间，然后用一个循环把每个元素都设置为指定的值😉。
3. 拷贝构造函数

template<typename T>
MyVector<T>::MyVector(const MyVector<T>& other) : size_(other.size_), capacity_(other.capacity_) {
    data = new T[capacity_];
    for (size_t i = 0; i < size_; ++i) {
        data[i] = other.data[i];
    }
}

😎拷贝构造函数就像是复制一个一模一样的魔法口袋哦😏。它创建一个新的 vector，大小和容量都和传入的other一样，然后把other中的元素一个一个地复制到新的 vector 中，这样新的 vector 就和原来的一模一样啦😉。

（三）析构函数实现🚮

template<typename T>
MyVector<T>::~MyVector() {
    if (data!= nullptr) {
        delete[] data;
    }
}

👀这个析构函数就像一个勤劳的清洁工🧹，当 vector 对象生命周期结束的时候，它会检查data指针是否为空。如果不为空，就释放掉data所指向的内存，避免内存泄漏，确保我们的程序干干净净、健健康康😎。

（四）获取元素数量和容量函数📏

1.获取元素数量函数

template<typename T>
size_t MyVector<T>::size() const {
    return size_;
}

😃这个函数就像一个小计数器一样，直接返回当前 vector 中元素的数量size_，简单又直接😎。
2. 获取容量函数

template<typename T>
size_t MyVector<T>::capacity() const {
    return capacity_;
}

👀它也是一样的简单，直接把数组的容量capacity_返回给我们，让我们知道这个魔法口袋最多能装多少东西😉。

（五）判断是否为空函数🤔

template<typename T>
bool MyVector<T>::empty() const {
    return size_ == 0;
}

😎这个函数就像一个小侦探🕵️‍♂️，检查元素数量size_是否为 0。如果是 0，那就说明 vector 是空的，就像魔法口袋里什么都没有一样，返回true；否则返回false😉。

（六）预留空间函数📦

template<typename T>
void MyVector<T>::reserve(size_t new_capacity) {
    if (new_capacity > capacity_) {
        T* new_data = new T[new_capacity];
        for (size_t i = 0; i < size_; ++i) {
            new_data[i] = data[i];
        }
        if (data!= nullptr) {
            delete[] data;
        }
        data = new_data;
        capacity_ = new_capacity;
    }
}

👀这个函数就像是给魔法口袋升级扩容一样😃！当我们预计要装更多元素的时候，就可以调用它。如果新的容量new_capacity比当前容量大，它就会分配一块新的更大的内存空间new_data，然后把原来的元素都复制到新空间里。最后，释放原来的内存，把data指针指向新的内存空间，并且更新容量capacity_，这样 vector 就有了更大的空间来装元素啦😎。

（七）调整大小函数📏

template<typename T>
void MyVector<T>::resize(size_t new_size, T value) {
    if (new_size > size_) {
        if (new_size > capacity_) {
            reserve(new_size);
        }
        for (size_t i = size_; i < new_size; ++i) {
            data[i] = value;
        }
    } else if (new_size < size_) {
        for (size_t i = new_size; i < size_; ++i) {
            data[i].~T();  // 手动调用析构函数
        }
    }
    size_ = new_size;
}

😉这个函数就像是重新调整魔法口袋的大小和里面的物品数量一样🧐。如果新的大小new_size比当前元素数量size_大，它会先检查容量是否足够，如果不够就调用reserve函数扩容。然后，用指定的值value填充新增加的位置。如果新的大小比当前数量小，它会手动调用析构函数来清理多余的元素，最后更新元素数量size_😎。

 

（八）下标操作符重载🎯

1. 非 const 版本

template<typename T>
T& MyVector<T>::operator[](size_t index) {
    return data[index];
}

😃这个非 const 版本的下标操作符重载就像一把神奇的钥匙🔑，可以让我们通过索引直接访问和修改 vector 中的元素。它返回data[index]的引用，这样我们就可以像操作普通变量一样对元素进行读写操作啦😎。
2. const 版本

template<typename T>
const T& MyVector<T>::operator[](size_t index) const {
    return data[index];
}

👀const 版本的下标操作符重载就像是一把只能看不能改的钥匙🔐，当我们有一个 const 的 vector 对象时，通过这个操作符只能读取元素的值，不能修改，确保了 const 对象的安全性😉。

 

（九）赋值操作符重载✍️

template<typename T>
MyVector<T>& MyVector<T>::operator=(const MyVector<T>& other) {
    if (this!= &other) {
        if (data!= nullptr) {
            delete[] data;
        }
        size_ = other.size_;
        capacity_ = other.capacity_;
        data = new T[capacity_];
        for (size_t i = 0; i < size_; ++i) {
            data[i] = other.data[i];
        }
    }
    return *this;
}

😎这个赋值操作符重载就像是把一个魔法口袋里的东西全部复制到另一个魔法口袋里一样🧙‍♂️。首先，它会检查是不是自我赋值，如果不是，就先释放掉原来的内存。然后，复制other的大小、容量和元素到当前 vector 中，最后返回当前对象的引用，这样就可以连续赋值啦😉。

（十）添加和删除元素函数🎯

1. 在末尾添加元素函数

template<typename T>
void MyVector<T>::push_back(const T& value) {
    if (size_ == capacity_) {
        reserve(capacity_ == 0? 1 : capacity_ * 2);
    }
    data[size_++] = value;
}

😃这个函数就像是往魔法口袋的末尾放一个新东西一样🎁。它先检查口袋是否还有空间，如果没有了，就调用reserve函数扩容（如果当前容量是 0，就扩为 1，否则扩为原来的两倍）。然后，把新元素放到data[size_]的位置，并且把元素数量size_加 1😎。
2. 删除末尾元素函数

template<typename T>
void MyVector<T>::pop_back() {
    if (size_ > 0) {
        --size_;
        data[size_].~T();  // 手动调用析构函数
    }
}

👀这个函数就像是从魔法口袋的末尾拿出一个东西一样😉。如果 vector 不为空，它就把元素数量size_减 1，并且手动调用析构函数来清理最后一个元素，就像把拿出来的东西处理掉一样😎。
3. 在指定位置插入元素函数

template<typename T>
void MyVector<T>::insert(size_t pos, const T& value) {
    if (pos > size_) {
        return;
    }
    if (size_ == capacity_) {
        reserve(capacity_ == 0? 1 : capacity_ * 2);
    }
    for (size_t i = size_; i > pos; --i) {
        data[i] = data[i - 1];
    }
    data[pos] = value;
    ++size_;
}

😎这个函数就像是在排队的人群中插入一个小伙伴一样👫。它先检查插入位置pos是否合法，如果合法，就检查容量是否足够，不够就扩容。然后，把pos及后面的元素都往后移一位，腾出空间，把新元素插入到pos位置，最后把元素数量size_加 1😉。
4. 删除指定位置元素函数

template<typename T>
void MyVector<T>::erase(size_t pos) {
    if (pos >= size_) {
        return;
    }
    for (size_t i = pos; i < size_ - 1; ++i) {
        data[i] = data[i + 1];
    }
    --size_;
    data[size_].~T();  // 手动调用析构函数
}

👀这个函数就像是从排队的人群中请走一个小伙伴一样😉。它先检查删除位置pos是否合法，如果合法，就把pos后面的元素都往前移一位，覆盖掉要删除的元素，然后把元素数量size_减 1，并且手动调用析构函数来清理最后一个元素😎。

（十一）迭代器相关函数🔍

1.迭代器类型定义

template<typename T>
typedef T* MyVector<T>::iterator;

😃这里我们定义了迭代器的类型，其实就是一个指向T类型的指针，这样我们就可以用这个指针来遍历 vector 中的元素啦😉。
2. 起始迭代器函数

template<typename T>
typename MyVector<T>::iterator MyVector<T>::begin() {
    return data;
}

👀这个函数就像是给我们一个指向 vector 开头的小箭头一样，它返回data指针，也就是指向第一个元素的位置，让我们可以从这里开始遍历元素😎。
3. 结束迭代器函数

template<typename T>
typename MyVector<T>::iterator MyVector<T>::end() {
    return data + size_;
}

😉这个函数就像是给我们一个指向 vector 末尾后面一个位置的小箭头，它返回data + size_，表示遍历到这个位置就结束了，因为这个位置并不存储实际元素，只是一个结束的标志😎。

---

四、总结😎

通过模拟实现 vector 类，我们仿佛走进了动态数组的魔法世界🧙‍♂️，深入了解了其背后的实现原理和技术细节。从存储结构的精心设计，到各种操作函数的巧妙实现，再到内存管理的严谨把控，每一个环节都像是魔法世界里的一块拼图🧩，缺一不可。

希望大家继续保持探索的热情，不断挖掘编程世界里的更多奥秘😉！加油哦💪！

---

以后我将深入研究继承、多态、模板等特性，并将默认成员函数与这些特性结合，以解决更复杂编程问题！欢迎关注我👉【A Charmer】