#pragma once
template<class T>
class MyVector
{ size_t size;
size_t len;
T*buff;
public:
MyVector();
~MyVector() { _clear();}
class MyIterator
{
T*it;
public:
MyIterator() { it = NULL; }
MyIterator(MyIterator&temp) { this->it = temp.buff; }
~MyIterator(){ it = NULL; }
void operator=(const T*p)
{ it = (T*)p; }
bool operator!=(T*temp)
{ return (it != temp); }
T& operator*()const
{ return *it; }
MyIterator& operator++()
{ it++; return *this; }
MyIterator& operator--()
{ it--; return *this; }
MyIterator& operator++(int)
{
MyIterator *temp = new MyIterator;
temp->it = it; this->it++;
return *temp;
}
MyIterator& operator--(int)
{
MyIterator *temp = new MyIterator;
temp->it = it; this->it--;
return *temp;
}
};
T& operator[](int i)const
{ return buff[i]; }
T* begin()const
{ return buff; }
T* end()const
{ return (buff + len); }
size_t getLen()
{ return len; }
size_t getSize()
{ return size; }
void _alloc();
MyVector& _cp(const MyVector&);
void push_back(const T& data);
void _clear();
T& at(int);
bool empty();
void swap(MyVector<T>&);
void swap(size_t, size_t);
MyVector& operator+=(const MyVector&);
};
template<class T>
MyVector<T>::MyVector()
{
buff = NULL;
size = len = 0;
}
template<class T>
void MyVector<T>::_alloc()
{
if (len >= size)
{
size = size + ((size >> 1) > 1 ? size >> 1 : 1);
buff = (T*)realloc(buff, sizeof(T)*size);
}
}
template<class T>
void MyVector<T>::push_back(const T& data)
{
_alloc();
buff[len++] = data;
}
template<class T>
void MyVector<T>::_clear()
{
if (buff)
free(buff);
size = len = 0;
buff = NULL;
}
template<class T>
T& MyVector<T>::at(int i)
{
if (i < 0 || i >= len)
printf("\a越界了!\n");
return buff[i];
}
template<class T>
bool MyVector<T>::empty()
{
if (buff)
return 0;
return 1;
}
template<class T>
MyVector<T>& MyVector<T>::_cp(const MyVector<T>&temp)
{
_clear();
size = len = temp.len;
_alloc();
for (int i = 0; i < len; i++)
this->buff[i] = temp.buff[i];
return *this;
}
template<class T>
void MyVector<T>::swap(MyVector<T>& tempVector)
{
MyVector temp;
temp._cp(*this);
this->_cp(tempVector);
tempVector._cp(temp);
temp._clear();
}
template<class T>
void MyVector<T>::swap(size_t subscript, size_t subscript2)
{
T temp = buff[subscript];
buff[subscript] = buff[subscript2];
buff[subscript2] = temp;
}
template<class T>
MyVector<T>&MyVector<T>::operator+=(const MyVector<T>&temp)
{
size_t tempLen = len;
size = len += temp.len;
_alloc();
for (size_t i = tempLen, j = 0; i < len; i++, j++)
buff[i] = temp.buff[j];
return *this;
}