c++ STL vector 的简易实现

template <class T>
class myVector
{
public:
    myVector():p(NULL),capacity(0),size(0)//默认构造函数
    {
    }
    myVector(int size)//默认赋值为0的构造函数
    {
        this->size=size;
        this->capacity=size;
        this->p=new T[capacity];
        for(int i=0;i<this->size;i++)
            this->p[i]=0;
    }
    myVector(int size,int data)//提供初值的构造函数
    {
        this->size=size;
        this->capacity=size;
        this->p=new T[capacity];
        for(int i=0;i<this->size;i++)
            this->p[i]=data;
    }
    //还可以提供其他一些用于初始化的构造函数

    //析构函数，释放掉唯一的指针
    ~myVector()
    {
        if(p!=NULL)
            delete[] p;
    }
    //拷贝构造函数
    myVector(const myVector &v)
    {
        this->capacity=v.capacity;
        this->size=v.size;
        this->p=new T[this->capacity];//分配内存空间
        memcpy(this->p,v.p,this->size* sizeof(T));
    }
    //遍历容器元素
    void print()
    {
        for(int i=0;i<this->size;i++)
            cout<<this->p[i]<<" ";
        cout<<endl;
    }
    //插入
    void push_back(T data)
    {
        if(this->p==NULL)
        {
            this->capacity=1;
            this->size=0;
            this->p=new T[capacity];
        }
        if(this->size==this->capacity)//扩容，重新分配内存空间
        {
            T *new_p=new T[this->capacity*2];
            memcpy(new_p,p,this->size* sizeof(T));
            this->capacity*=2;
            delete[]p;
            p=new_p;
        }
        this->p[this->size++]=data;
    }
    //删除
    void pop_back()
    {
        if(this->size>1)
        {
            this->p[this->size-1]=0;
            this->size--;
        }
        error();
    }

    //指定位置删除(元素后移)
    void insert(int pos,T data)
    {
        if(pos>=0&&pos<=this->size)
        {
            if(this->size==this->capacity)//已经满了，扩容
            {
                T *new_p=new T[this->capacity*2];
                memcpy(new_p,this->p,this->size* sizeof(T));
                this->capacity*=2;
                delete[]p;
                p=new_p;
            }
            for(int i=this->size;i>pos;i--)
                this->p[size]=this->p[size-1];
            this->p[pos]=data;
            this->size++;
        }
        error();
    }
    void error()
    {
       cout<<"数组越界！";
    }
    void clear()
    {
        this->size=0;
    }
    //重载[]运算符
    T &operator[](int index)
    {
        if(index>=0&&index<this->size)
            return this->p[index];
        error();
    }
    //重载=运算符
    T &operator=(const myVector &v)
    {
        if(this->p!=NULL)
        {
            delete []p;
            this->capacity=0;
            this->size=0;
            this->p=NULL;
        }
        this->capacity=v.capacity;
        this->size=v.size;
        this->p=new T[this->capacity];
        memcpy(p,v.p,this->size* sizeof(T));
    }
    int Size()
    {
        return this->size;
    }
    int Capacity()
    {
        return this->capacity;
    }

private:
    T *p;
    int capacity;
    int size;
};

//测试函数
void test()
{
    myVector<int> myVector1(3,1);
    myVector1.print();
    cout<<myVector1.Size()<<"--"<<myVector1.Capacity()<<endl;
    for(int iter = 0;iter<11;iter++)
    {
        myVector1.push_back(iter);
        myVector1.print();
        cout<<"size:"<<myVector1.Size()<<" capacity:"<<myVector1.Capacity()<<endl;
    }
    myVector1.pop_back();
    myVector1.pop_back();
    myVector1.pop_back();
    myVector1.print();
    myVector1[3]=10086;
    myVector1.print();

    myVector<int > myVector2(3,1);
    myVector2.print();
    myVector2.insert(0,4);
    myVector2.insert(1,222);
    myVector2.insert(myVector2.Size(),333);
    myVector2.print();
}

int main()
{
    test();
    return 0;
}

vector函数 底层通过capacity 和size变量以及一个T类型的指针 动态的实现 数组的动态增长，通过重载[]运算符提供了随机访问，每次插入新的元素，会检查当前的size是否和capacity相等，如果相等，则重新开辟一块2*capacity大小的内存，并使用memcpy函数将内容原来的数据拷贝过去，还可以继续添加更多的函数来丰富该类的功能。