c++ vector模拟实现代码

1. vector 模拟实现 —— 基本思路

Vector 是一个可以动态扩容的顺序容器，其内部使用数组存储数据。当 Vector 容量不足时，会自动扩容。通过复制当前容量大小的内存空间并将原元素复制到新的内存空间中来实现。

具体实现的过程可分为以下几个步骤：

• 定义容器的基本特性，包括存储元素的数组地址，当前元素数量，当前容量大小。
• 容器的初始化。初始化时分配一块指定大小的内存空间，用于存储容器的元素。
• 容器的插入元素操作。插入元素时，首先需要判断是否需要扩容。如果需要扩容，则需要申请一块新的内存空间，并将原有元素复制到新的内存空间中。插入元素后需要更新元素数量、容量大小以及新元素在数组中的位置等属性。
• 容器的查找元素操作。查找元素时，需要遍历整个数组，逐个比较元素的值。如果找到了指定的元素，则返回该元素的位置；否则返回一个特殊值。例如：当制定元素不存在时，返回 -1。

• 容器的删除元素操作。删除元素时，需要将指定元素的位置从容器中移除，并从该位置开始将后面所有的元素向前移动。

• vector 模拟实现 —— 示例说明

下面是一个简单的 vector 模拟实现代码（以 C++ 为例），代码实现了 vector 的基本功能，包括构造函数、析构函数、插入函数、查找函数、删除函数等。

#include <iostream>
using namespace std;

template<class T>
class Vector
{
private:
    T* _data;           // 指向存储元素的数组地址
    int _size;          // 当前元素数量
    int _capacity;      // 当前容量大小

public:
    // 默认构造函数
    Vector()
    {
        _size = 0;
        _capacity = 5;
        _data = new T[_capacity];
    }

    // 拷贝构造函数
    Vector(const Vector& vec)
    {
        _size = vec._size;
        _capacity = vec._capacity;
        _data = new T[_capacity];
        for (int i = 0; i < _size; i++)
        {
            _data[i] = vec._data[i];
        }
    }

    // 析构函数
    ~Vector()
    {
        _size = 0;
        _capacity = 0;
        delete[] _data;
    }

    // 获取元素数量
    int size()
    {
        return _size;
    }

    // 获取容量大小
    int capacity()
    {
        return _capacity;
    }

    // 插入元素
    void push_back(const T& value)
    {
        if (_capacity == _size)
        {
            resize(_capacity * 2);
        }
        _data[_size] = value;
        _size++;
    }

    // 查找元素
    int find(const T& value)
    {
        for (int i = 0; i < _size; i++)
        {
            if (_data[i] == value)
            {
                return i;
            }
        }
        return -1;
    }

    // 删除元素
    void erase(int pos)
    {
        if (pos >= _size || pos < 0)
        {
            return;
        }
        for (int i = pos; i < _size - 1; i++)
        {
            _data[i] = _data[i + 1];
        }
        _size--;
    }

    // 重设容器大小
    void resize(int new_capacity)
    {
        T* new_data = new T[new_capacity];
        for (int i = 0; i < _size; i++)
        {
            new_data[i] = _data[i];
        }
        delete[] _data;
        _data = new_data;
        _capacity = new_capacity;
    }

    // 打印元素
    void print()
    {
        for (int i = 0; i < _size; i++)
        {
            cout << _data[i] << " ";
        }
        cout << endl;
    }
};

// 示例一：测试插入元素和扩容
void example1()
{
    Vector<int> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    vec.push_back(4);
    vec.push_back(5);

    // 当容器中的元素数量等于容量大小时，会自动扩容为原容量大小的两倍
    vec.push_back(6);
    vec.push_back(7);

    vec.print();    // 输出：1 2 3 4 5 6 7
}

// 示例二：测试查找元素和删除元素
void example2()
{
    Vector<int> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    vec.push_back(4);
    vec.push_back(5);

    // 查找指定的元素
    int pos = vec.find(3);
    cout << "position: " << pos << endl;   // 输出：position: 2

    // 删除指定位置上的元素
    vec.erase(1);
    vec.print();    // 输出：1 3 4 5
}

int main()
{
    example1();
    example2();
    return 0;
}

在第一个示例中，我们插入了 7 个元素，当容器中的元素数量等于容量大小时，自动扩容为原容量大小的两倍。在第二个示例中，我们查找了一个指定的元素，并删除了指定位置上的元素。在输出时使用了容器的 print() 函数，方便观察元素的具体内容。