introduction to algorithms 菜鸟笔记 vector

//author:yydrewdrew

#define ERROR -1

#define ALLOC_STEP 5

template <class T>
class vector
{
public:
explicit vector();
explicit vector(const T &t,size_t num);
explicit vector(const T *p,size_t num);
void push_back(const T &t);
void push_front(const T &t);
T pop_back();
T pop_front();
T *insert(const T &t,const size_t pos);
T remove(size_t pos);
void set(const size_t pos);
vector(const vector<T> &obj);
bool empty()const;
void clear();
size_t getsize()const;
vector<T> &operator = (const vector<T> &obj);
bool operator == (const vector<T> &obj)const;
bool operator != (const vector<T> &obj)const;
T &operator [] (const size_t pos);
virtual ~vector();
private:
T *p;
void New();
void Destory();
size_t number;
size_t size;
};

template <class T>
void vector<T>::set(const size_t pos)
{
if (pos < 0 || pos > number)
{
throw ERROR;
}
else
{
p[pos] = t;
}
}

template <class T>
T &vector<T>::operator[](const size_t pos)
{
if (pos < 0 || pos > number)
{
throw ERROR;
}
else
{
return p[pos];
}
}

template<class T>
void vector<T>::New()
{
if (number == size)
{
T *_p = new T[size + ALLOC_STEP];
while (number--)
{
_p[number] = p[number];
}
delete []p;
p = _p;
number = size;
size += 5;
}
}

template<class T>
vector<T>::vector<T>(const T &t,size_t num):number(num),size(num + ALLOC_STEP)
{
if (p = NULL || num<=0)
{
this->p = NULL;
}
else
{
p = new T[size];
while(num--)
{
p[num] = t;
}
}
}

template<class T>
vector<T>::vector<T>(const T *p,size_t num):number(num),size(num + ALLOC_STEP)
{
if (p == NULL || num <= 0)
{
this->p = NULL;
}
else
{
this->p = new T[size];
while (num--)
{
this->p[num] = p[num];
}
}
}

template<class T>
void vector<T>::push_back(const T &t)
{
New();
p[number++] = t;
}

template <class T>
void vector<T>::push_front(const T &t)
{
New();
int tem_num = number;
while (tem_num--)
{
p[++tem_num] = p[tem_num];
}
p[0] = t;
}

template<class T>
T vector<T>::pop_back()
{
if (number <= 0)
{
throw ERROR;
}
else
{
--number;
return p[number];
}
}

template<class T>
T vector<T>::pop_front()
{
if (number <= 0)
{
throw ERROR;
}
else
{
const T _t = p[0];
int tem_num = 1;
while (tem_num < number)
{
p[tem_num - 1] = p[tem_num];
++tem_num;
}
--number;
return _t;
}
}

template<class T>
T *vector<T>::insert(const T &t,const size_t pos)
{
if (pos < 0 || pos > number)
{
throw ERROR;
}
else
{
New();
size_t pos_tem = number;
while (pos_tem > pos)
{
p[pos_tem] = p[pos_tem - 1];
--pos_tem;
}
p[pos] = t;
++number;
return p + pos;
}
}

template<class T>
T vector<T>::remove(size_t pos)
{
if (pos < 0 || pos >= number)
{
throw ERROR;
}
else
{
const T _t = p[pos];
while(pos < number - 1)
{
p[pos] = p[pos + 1];
++pos;
}
--number;
return _t;
}
}

template<class T>
vector<T> &vector<T>::operator = (const vector<T> &obj)
{
if (this != &obj)
{
if (obj.p == NULL)
{
Destory();
p = NULL;
number = 0;
size = 0;
}
else
{
size_t num_tem = obj.number;
T *_p = new T[obj.size];
while (num_tem--)
{
_p[num_tem] = obj.p[num_tem];
}
Destory();
p = _p;
number = obj.number;
size = obj.size;
}
}
return *this;
}

template <class T>
vector<T>::vector<T>():p(NULL),number(0),size(0){}

template<class T>
bool vector<T>::operator == (const vector<T> &obj)const
{
if (number != obj.number)
{
return false;
}
size_t num_tem = 0;
bool is = true;
while (num_tem < number)
{
if (p[num_tem] != obj.p[num_tem])
{
is = false;
break;
}
++num_tem;
}
return is;
}

template<class T>
void vector<T>::Destory()
{
delete []p;
p = NULL;
size = 0;
number = 0;
}

template<class T>
bool vector<T>::operator != (const vector<T> &obj)const
{
if (number != obj.number)
{
return true;
}
size_t num_tem = 0;
bool is = false;
while (num_tem < number)
{
if (p[num_tem] != obj.p[num_tem])
{
is = true;
break;
}
++num_tem;
}
return is;
}

template<class T>
vector<T>::~vector<T>()
{
Destory();
}

template<class T>
vector<T>::vector<T>(const vector<T> &obj)
{
number = obj.number;
size = obj.size;
if (obj.p != NULL)
{
p = new T[size];
size_t num_tem = number;
while (num_tem--)
{
p[num_tem] = obj.p[num_tem];
}
}
}

template <class T>
bool vector<T>::empty()const
{
return (number == 0);
}

template<class T>
void vector<T>::clear()
{
Destory();
}

template<class T>
size_t vector<T>::getsize()const
{
return number;
}