数据结构和算法分析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_