/*

* 用数组的方式实现线性表

*/

#include<iostream>

using namespace std;

template <typename Object>

class Vector

{

private:

    int theSize;

    int theCapacity;

    Object * objects;

public:

    //构造函数

    explicit Vector(int initSize = ) : theSize(initSize), theCapacity(initSize + SPACE_CAPACITY) {

        objects = new Object[theCapacity];

    }

    //拷贝构造函数

    Vector(const Vector &rhs) :objects(NULL)

    {

        operator=(rhs);

    }

    //析构函数

    ~Vector()

    {

        delete[] objects;

    }

    //重载复制操作符

    const Vector &operator=(const Vector &rhs)

    {

        if (this != rhs)

        {

            delete[] objects;

            theSize = rhs.theSize;

            theCapacity = rhs.theCapacity;

            objects = new Object[capacity()];

            for (int i = ; i < size();++i)

            {

                objects[i] = rhs.objects[i];

            }

        }

        return *this;

    }

    //调整Vector的大小

    void resize(int newSize)

    {

        if (newSize > theCapacity)

        {

            reverse(newSize *  + );

        }

        theSize = newSize;

    }

    //调整容量

    void reverse(int newCapacity)

    {

        if (newCapacity < theSize)

            return;

        Object *oldArray = objects;

        objects = new Object[newCapacity];

        for (int i = ; i < size(); ++i)

        {

            objects[i] = oldArray[i];

        }

        theCapacity = newCapacity;

        delete[] oldArray;

    }

    //重载取元素操作符[]

    Object & operator[](int index)

    {

        return objects[index];

    }

    //重载取元素操作符[] 返回值为左值不可修改

    Object & operator[](int index) const

    {

        return objects[index];

    }

    //判断是否为空

    bool empty()

    {

        return theSize == ;

    }

    //获得Vector的大小

    int size() const

    {

        return theSize;

    }

    //获得theCapacity的大小

    int capacity() const

    {

        return theCapacity;

    }

    //在尾部插入元素

    void push_back(const Object &x)

    {

        if (theSize == theCapacity)

        {

            reverse( * theCapacity + );

        }

        objects[theSize++] = x;

    }

    //弹出尾部元素

    void pop_back()

    {

        theSize--;

    }

    //返回尾部元素

    const Object &back() const

    {

        return objects[theSize - ];

    }

    //使用指针定义迭代器

    typedef Object * itreator;

    typedef const Object * const_itreator;

    //获取开始的迭代器

    itreator begin()

    {

        return &objects[];

    }

    const_itreator begin() const

    {

        return &objects[];

    }

    //获取结束的迭代器

    itreator end()

    {

        return &objects[size()];

    }

    const_itreator end() const

    {

        return &objects[size()];

    }

    enum { SPACE_CAPACITY =  };

};

int main()

{

    Vector<int> vec;

    vec.push_back();

    vec.push_back();

    for (auto it = vec.begin(); it != vec.end();++it)

    {

        cout << *it << ' ';

    }

    return ;

}