c++实现vector容器

// 自定义vector类型
template <typename Object>
class Vector{
    int mSize;  // vector元素数量
    int capacity; // vector容量
    Object *object; // vector首指针, 除非扩大容量， 首指针不允许修改
    static const int SPACE_CAPACITY = 16;
public:
    /**
     * decryption: 构造函数
     * @param initSize 初始vector尺寸
     */
    explicit Vector(int initSize): mSize(initSize), capacity(initSize + SPACE_CAPACITY){
         object = new Object[capacity];  // 堆区开辟内存
    }
    // 列表初始化
    Vector(initializer_list<Object> initList):mSize(initList.size()), capacity(initList.size() + SPACE_CAPACITY){
        object = new Object[capacity];
        auto initPtr = object;
        for (const auto &item : initList){
            *initPtr++ = item;
        }
    }
    // 拷贝构造函数
    Vector(const Vector &rhs): mSize(rhs.mSize), capacity(rhs.capacity){
        object = new Object[capacity];
        for (auto item: rhs){  // 拷贝所有元素
            *object++ = item;
        }
    }

    // 析构函数
    ~Vector(){
        delete[] object;
    }
    // 修改尺寸
    void resize(int newSize){
        if (newSize > capacity){ // 大于当前容量
            this->reserve(newSize*2);  // 开辟当前尺寸的2倍容量
        }
        mSize = newSize;
    }

    // 重设容量
    void reserve(int newCapacity){
        if (newCapacity < mSize) return;  // 什么也不做
        auto *newObject = new Object[newCapacity];  // 开辟设置的空间
        for (int i = 0; i < mSize; ++i){
            newObject[i] = move(object[i]); // 原来的元素移动
        }
        capacity = newCapacity;
        swap(newObject, object);
        delete[] newObject;
    }

    // 重载[]运算符
    Object & operator[](int index){
        return object[index];
    };
    // const版本重载
    const Object & operator[](int index) const{
        return object[index];
    }
    [[nodiscard]] bool empty() const{
        return mSize == 0;
    }

    [[nodiscard]] int size() const{
        return mSize;
    }

    using iter = Object*;  // 定义迭代器
    using cIterr = const Object*;

    iter begin(){
        return &object[0];
    }

    iter end(){
        return &object[mSize];  // 返回尾指针
    }

    Object &back(){
        return object[--mSize];
    }

    Object & front(){
        return object[0];
    }

    void push_back(const Object &item){
        if (mSize == capacity)
            reserve(mSize*2 + 1);
        object[mSize++] = item;
    }
};