數據結構和算法分析c++：向量的實現

vector是比較常用的結構，在C++的STL中就有了vector的實現，爲避免與庫函數混淆，類模板命名爲Vector，它的本質還是基本的數組。
下面我們來看一下Vector的具體c++實現吧。

#ifndef REDEFINE_VECTOR_H_  
#define REDEFINE_VECTOR_H_  

template <typename Object>
class Vector
{
public:
    //默認構造函數是explicit顯式的,所有單參數構造函數必須是顯式的，以避免後臺的類型轉換，例如Vector<Object> obj = 37；
    explicit Vector(int initSize = 0) 
        : theSize(initSize),                        //theSize Vector實際的元素的個數；
        theCapacity(initSize + SPARE_CAPACITY) {    //theCapacity Vector內數組實際的大小，SPARE_CAPACITY是預留的空間，一個指數量，一個指能力；
        objects = new Object[theCapacity];          //申請一個容量爲theCapacity的動態數組；
    }

    //複製構造函數，由現有Vector對象，創建新的Vector對象；
    Vector(const Vector & rhs) :objects(nullptr) {  //C++ 11 nullptr 表示空指針,優於C的NULL，可防止c++程序的某些重載函數出現歧義；
        operator = (rhs);                           //lhs、rhs指的是 = 運算符左、右邊的操作數，goolge的c++編碼規範不推薦此種寫法；
    }

    //析構函數
    ~Vector() {
        delete[] objects;                           //delete原則是和new對應，new--delete，new[]--delete[],new[]前四位保存數組大小的信息，delete[]時調用數組大小次析構函數；
    }

    //複製賦值運算符，將一個Vector複製給另外一個；
    const Vector& operator=(const Vector& rhs) {
        if (this != &rhs) {                         //如果地址相同，直接返回；
            delete[] objects;                       //數組不能直接複製，只能刪除再建；
            theSize = rhs.theSize;
            theCapacity = rhs.theCapacity;
            objects = new Object[rhs.theCapacity];          
            for (int k = 0; k < rhs.theSize; k++) {
                objects[k] = rhs.objects[k];
            }
        }
        return *this;                               //返回自身，是爲了實現連續賦值的效果，例如Vector<Object> obj1, obj2, obj3; obj1 = obj2 = obj3；
    }

    //重置Vector內對象的數量；
    void resize(int newSize) {
        if (newSize > theCapacity) {                //新的大小比原來的容量大，才需要擴展容量；
            reserve(newSize * 2 + 1);               //翻倍擴容是爲了增加效率，+1是防止爲0的情況；
        }
        theSize = newSize;
    }

    //修改Vector容量；
    void reserve(int newCapacity) {
        if (newCapacity < theSize) {                //修改的容量不允許小於Vector內當前對象的數量；
            return;
        }
        Object* oldArray = objects;                 //舊的數據
        objects = new Object[newCapacity];          //申請新的數組，大小爲新的容量；
        for (int k = 0; k < theSize; k++) {         //複製舊的數組給新的數組；
            objects[k] = oldArray[k];  
        }
        theCapacity = newCapacity;                  //保存新的容量；
        delete[] oldArray;                          //刪除舊的數組；
    }

    //重載[]運算符，使Vector下標返回下標對應位置的對象；
    Object & operator[](int index) {
        return objects[index];
    }
    //const 形式
    const Object& operator[](int index) const {
        return objects[index];
    }

    //判斷Vector是否爲空；
    bool empty() const {
        return theSize == 0;
    }

    //返回Vector對象的個數；
    int size() const {
        return theSize;
    }

    //返回Vector的容量；
    int capacity() const {
        return theCapacity;
    }

    //在Vector尾部添加新對象；
    void push_back(const Object& x) {
        if (theSize == theCapacity) {               //判斷是否需要擴容；
            reserve(2 * theCapacity + 1);  
        }
        objects[theSize++] = x;                     //先賦值再對theSize自增；
    }

    //刪除Vector尾部的對象，直接另theSize減一；
    void pop_back() {
        theSize--;
    }

    //返回Vector尾部的對象；
    const Object& back() const {
        return objects[theSize - 1];
    }

    typedef Object* iterator;                       //聲明迭代器；
    typedef const Object* const_iterator;           //聲明常量迭代器；

    //返回迭代器的首部，即Vector的首對象；
    iterator begin() {
        return &objects[0];
    }

    const_iterator begin() const {
        return &objects[0];
    }

    //返回迭代器的尾部，即Vector的最後一個對象的對應位置的下一個位置的對象；
    iterator end() {
        return &objects[size()];
    }

    const_iterator end() const {
        return &objects[size()];
    }

    enum { SPARE_CAPACITY = 16 };                   //初始預留的容量  

private:
    int theSize;                                    //對象的數量
    int theCapacity;                                //數組大小
    Object* objects;                                //對象數組
};

#endif //REDEFINE_VECTOR_H_