简易Vector实现

template <typename Object>
class Vector {
public:
    explicit Vector(int initSize = 0) : theSize(initSize), theCapacity(initSize + SPARE_CAPACITY) {
        objects = new Object[theCapacity];
    }
    Vector(const Vector& rhs) : objects(NULL) {
        operator=(rhs);
    }
    ~Vector() { delete[] objects; }

    void operator= (const Vector& rhs) {
        if (this != &rhs) {
            delete[] objects;
            theSize = rhs.theSize;
            theCapacity = rhs.theCapacity;
            objects = new Object[capacity()];
            for (int i = 0; i < size(); i++)
                objects[i] = rhs[i];
        }
    }

    void reserve(int newCapacity) {
        if (newCapacity > theCapacity) {
            Object* oldArray = objects;
            objects = new Object[newCapacity];
            for (int i = 0; i < size(); i++)
                objects[i] = oldArray[i];
            theCapacity = newCapacity;
            delete[] oldArray;
        }
    }

    Object& operator[](int index) {
        return objects[index];
    }
    const Object& operator[](int index) const {
        return objects[index];
    }

    bool empty() const {
        return size() == 0;
    }
    int size() const {
        return theSize;
    }
    int capacity() const{
        return theCapacity;
    }

    void push_back(const Object& object) {
        if (capacity() == size()) {
            reserve(2 * theCapacity + 1);

        }
        objects[theSize++] = object;
    }

    void pop_back() {
        theSize--;
    }

    const Object& back() const{
        return objects[theSize - 1];
    }

    typedef Object* iterator;
    typedef const Object* const_iterator;

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

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

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

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


    enum {SPARE_CAPACITY=16};

private:
    int theSize;
    int theCapacity;
    Object* objects;
};