// 自定義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;
    }
};