c++ stl库 vector简单的实现

//stl库中vector是一个自动管理的动态数组；

//其实只要明白vector的类型是一个数组，怎么去实现它，其实就好办了；

//我选择了一种简单的方式去实现它;//定义一个步长（WALK_LENGTH）；

//在数组空间不够的时候，重新申请 allocCount+WALK_LENGTH 长度的内存；

//这样避免了，每次vector元素增加的时候，去重新申请空间；

//当然，不好的地方也很明显。就是会浪费一定的空间。但是时间效率上会提高很多；

//因为vector，可以支持下标访问，而且效率很快，所以没必要去构造一个iterator；

//通过分析代码，可以发现vector的优缺点

//1、随即访问元素效率很高；

//2、push_back的效率也会很高；

//3、push_front的效率则非常的低，不建议使用；

//4、insert，需要把插入位置以后的元素，全部后移，效率比较低，不建议使用；

//5、erase，需要把删除位置后面的元素，全部前移，效率比较低，不建议使用；

//6、当内存不够的时候，需要重新申请内存，在把以前的元素拷贝过来，这个时候，效率也是比较低的；

//有不足的地方，还希望大家指正

#ifndef _MY_VECTOR_H_
#define _MY_VECTOR_H_

#include <assert.h>

template<typename T>
class myVector
{
private:
//walk length
//myVector each time increase space length
#define WALK_LENGTH 64;

public:
//default constructor
myVector():array(0),count(0),allocCount(0)
{

}

//
myVector(const T& t,unsigned int n):array(0),count(0),allocCount(0)
{
while(n--)
{
push_back(t);
}
}

//copy constructor
myVector(const myVector<T>& other):array(0),count(0),allocCount(0)
{
*this = other;
}

//= operator
myVector<T>& operator =(myVector<T>& other)
{
if(this == &other)
return *this;

clear();

count = other.size();
allocCount = other.allocSize();
array = new T[allocCount];
for(unsigned int i = 0 ;i<count;++i)
{
array[i] = other[i];
}

return *this;
}

//destructor
~myVector()
{
clear();
}

//the pos must be less than myVector.size();
T& operator[](unsigned int pos)
{
assert(pos<count);
return array[pos];
}

//element count
unsigned int size()
{
return count;
}

//alloc count
unsigned int allocSize()
{
return allocCount;
}

//is  empty
bool empty()
{
return count == 0;
}

//clear myVector
void clear()
{
deallocator(array);
array = 0;
count = 0;
allocCount = 0;
}

//adds an element in the back of myVector
void push_back(const T& t)
{
insert_after(count-1,t);
}

//adds an element int the front of myVector
void push_front(const T& t)
{
insert_before(0,t);
}

//inserts an element after the pos
//the pos must be in [0,count);
void insert_after(int pos,const T& t)
{
insert_before(pos+1,t);
}

//inserts an element before the pos
//the pos must be less than the myVector.size()
void insert_before(int pos,const T& t)
{
if(count==allocCount)
{
T* oldArray = array;

allocCount += WALK_LENGTH;
array = allocator(allocCount);
//memcpy(array,oldArray,count*sizeof(T)):
for(unsigned int i = 0 ;i<count;++i)
{
array[i] = oldArray[i];
}
deallocator(oldArray);
}

for(int i = (int)count++;i>pos;--i)
{
array[i] = array[i-1];
}
array[pos] = t;
}

//erases an element in the pos;
//pos must be in [0,count);
void erase(unsigned int pos)
{
if(pos<count)
{
--count;
for(unsigned int i = pos;i<count;++i)
{
array[i] = array[i+1];
}
}
}

private:
T*  allocator(unsigned int size)
{
return new T[size];
}

void deallocator(T* arr)
{
if(arr)
delete[] arr;
}
private:
T*				array;
unsigned int	count;
unsigned int	allocCount;
};

#endif

//下面的是测试代码

void printfVector(myVector<int>& vector1)
{
for(unsigned int i = 0 ; i < vector1.size();++i)
{
cout<<vector1[i]<<",";
}
cout<<"alloc size = "<<vector1.allocSize()<<",size = "<<vector1.size()<<endl;
}

void main()
{
myVector<int> myVector1;
myVector<int> myVector2(0,10);
myVector2.push_front(1);
myVector2.erase(11);
printfVector(myVector2);
myVector1.push_back(2);
myVector1.push_front(1);
printfVector(myVector1);
myVector1.insert_after(1,3);
printfVector(myVector1);

myVector2 = myVector1;
myVector2.insert_before(0,0);
myVector2.insert_before(1,-1);
printfVector(myVector2);
}