#include <iostream>

#include <assert.h>

#define DOUBLE_SIZE

using namespace std;

template <typename T>

class Vector {

};

template <typename T> Vector<T>::Vector(const T& t, unsigned int n):array(0), vsize(0), vcapacity(0) {

while(n--) {

push_back(t);

}

}

template <typename T> Vector<T>::Vector(const Vector<T>& other) {

array = other.array;

vsize = other.vsize;

vcapacity = other.vcapacity;

}

template <typename T> unsigned int Vector<T>::size() {

return vsize;

}

template <typename T> unsigned int Vector<T>::capacity() {

return vcapacity;

}

template <typename T> bool Vector<T>::empty() {

return (vsize == 0);

}

template <typename T> void Vector<T>::clear() {

destory(array);

array = 0;

vsize = 0;

vcapacity = 0;

}

template <typename T> void Vector<T>::push_back(const T& t) {

insert_after(vsize - 1, t);

}

template <typename T> void Vector<T>::insert_after(int pos, const T& t) {

insert_before(pos + 1, t);

}

template <typename T> void Vector<T>::push_front(const T& t) {

insert_before(0, t);

}

template <typename T> void Vector<T>::insert_before(int pos, const T& t) {

if(vsize == vcapacity) {

T *old_array = array;

#ifdef DOUBLE_SIZE

if(vcapacity == 0)

vcapacity = 1;

vcapacity = vcapacity << 1;

#else

vcapacity += ADD_SIZE;

#endif

array = allocator(vcapacity);

for (unsigned int i = 0; i < vsize; ++i)

array[i] = old_array[i];

destory(old_array);

}

for(int i = (int)vsize++; i > pos; --i)

array[i] = array[i - 1];

array[pos] = t;

}

template <typename T> void Vector<T>::erase(unsigned int pos) {

if(pos < vsize) {

--vsize;

for(unsigned int i = pos; i < vsize; ++i)

array[i] = array[i + 1];

}

}

template <typename T> void Vector<T>::print() {

for(unsigned int i = 0; i < size(); ++i) {

cout << array[i] << " ";

}

cout << endl;

cout << "Real time size = " << size() << endl;

cout << "The capacity = " << capacity() << endl << endl;

}

template <typename T>T* Vector<T>::allocator(unsigned int size){

return new T[size];

}

template <typename T> void Vector<T>::destory(T *array) {

if(array)

delete[] array;

}

template <typename T> Vector<T>& Vector<T>::operator =(Vector<T>& other) {

/* 1. 判断是否为同一个对象

if(this == &other)

return *this;

clear();

vsize = other.size();

vcapacity = other.capacity();

array = new T[vcapacity];

for(unsigned int i = 0; i < vsize; ++i) {

array[i] = other[i];

}

return *this;

}

template <typename T> T& Vector<T>::operator[](unsigned int pos) {

assert(pos < vsize);

return array[pos];

}

int main() {