STL container 之 vector的实现

   辛辛苦苦写了一个上午的数据结构，代码基本能将vector的功能实现，其中vector用vectors代替，iterator用iterators代替，支持随机访问

  代码写的比较粗糙，为了节省时间，对于越界问题没有做特殊处理，代码风格不是特别好。功能经过了自己的检验，如果有写错的地方，希望大家能指出来，我会及时改正~~~

//stl 全部 左开右闭
//为了节省时间 嗯 时间就是生命 TLE go died !!! 所以插入移除的位置没做特别判断 只要合理利用 就没问题
#include <iostream>
#include <cstdlib>
using namespace std;
template <typename _Tp,int n=100>
class vectors
{
    public:
       class iterators
       {
           public:
              friend class vectors;
              iterators() {pointer=NULL;}
              iterators(const iterators& it) {pointer=it.pointer;}
              iterators(_Tp* it) {pointer=it;}
              iterators& operator =  (iterators& it) {pointer=it.pointer;return *this;}
              iterators& operator +  (int len) {pointer=pointer+len;return *this;}
              iterators& operator -  (int len) {pointer=pointer+len;return *this;}
              iterators& operator ++ () {pointer++;return *this;}
              iterators& operator -- () {pointer--;return *this;}
              iterators  operator ++ (int) {iterators it(*this);pointer++;return it;}
              iterators  operator -- (int) {iterators it(*this);pointer--;return it;}
              bool operator != (iterators it) {return it.pointer!=pointer;}
              _Tp& operator *  () {return *pointer;}
           private:
              _Tp* pointer;
       };
       vectors(int len=0) {p=(_Tp*)malloc(sizeof(_Tp)*(sizes=n));length=len;}
       vectors(const vectors<_Tp,n>&);
       ~vectors() {free(p);}
       iterators begin() {return iterators(p);}
       iterators end() {return iterators(p+length);}
       iterators rbegin() {return iterators(p+length-1);}
       iterators rend() {return iterators(p-1);}
       _Tp  front() {return *p;}
       _Tp  back() {return *(p+length-1);}
       iterators insert(iterators,_Tp);
       void insert(iterators,iterators,iterators);
       void insert(iterators,int,_Tp);
       iterators erase(iterators);
       iterators erase(iterators,iterators);
       _Tp& operator[] (int pos) {return p[pos];}
       vectors<_Tp,n>& operator = (const vectors<_Tp,n>&);
       void pop_back() {length--;}
       void push_back(_Tp);
       void assign(int len,_Tp elem) {while(len--) *(p+len)=elem;}
       void assign(_Tp* s,_Tp* e) {_Tp* it=p;while(s!=e) *(it++)=*(s++);}
       void clear() {free(p); p=(_Tp*)malloc(sizeof(_Tp)*(sizes=n));length=0;}
       void resize(size_t len) {p=realloc(p,sizeof(_Tp)*(length=sizes=len));}
       void reserve(size_t len) {p=realloc(p,sizeof(_Tp)*(sizes=len));}
       int size() {return length;}
       size_t capacity() {return sizeof(_Tp)*length;}
       bool empty() {return length==0;}
    private:
       _Tp* p;
       int length;
       int sizes;
};
template <typename _Tp,int n>
vectors<_Tp,n>::vectors(const vectors<_Tp,n>& tmp)
{
    this->p=(_Tp*)malloc(sizeof(_Tp)*tmp.sizes);
    this->sizes=tmp.sizes;this->length=tmp.length;
    for(int i=0;i<tmp.length;i++)
        *(this->p+i)=*(tmp.p+i);
}
template <typename _Tp,int n>
void vectors<_Tp,n>::push_back(_Tp val)
{
    if(length++==sizes) p=(_Tp*)realloc(p,sizeof(_Tp)*(sizes+=100));
    if(p==NULL) return;
    p[length-1]=val;
}
template <typename _Tp,int n>
vectors<_Tp,n>& vectors<_Tp,n>::operator = (const vectors<_Tp,n>& tmp)
{
    this->p=(_Tp*)malloc(sizeof(_Tp)*tmp.sizes);
    this->sizes=tmp.sizes;this->length=tmp.length;
    memcpy(this->p,tmp.p,sizeof(_Tp)*tmp.length);
}
template <typename _Tp,int n>
typename vectors<_Tp,n>::iterators vectors<_Tp,n>::insert(iterators s,_Tp elem)
{
    _Tp* pos=s.pointer;
    _Tp* po=p+length-1;
    if((length++==sizes)) p=(_Tp*)realloc(p,sizeof(_Tp)*(sizes+=100));
    if(p==NULL) return NULL;
    while(po>=pos)
    {
        *(po+1)=*po;
        po--;
    }
    *pos=elem;
    return iterators(pos);
}
template <typename _Tp,int n>
void vectors<_Tp,n>::insert(iterators s,int len,_Tp elem)
{
    _Tp* pos=s.pointer;
    _Tp* po=p+length-1;
    if((length+=len)>=sizes) p=(_Tp*)realloc(p,sizeof(_Tp)*(sizes+=max(100,len)));
    if(p==NULL) return;
    while(po>=pos)
    {
        *(po+len)=*po;
        po--;
    }
    for(_Tp* ps=pos;ps!=pos+len;ps++)
        *ps=elem;
}
template <typename _Tp,int n>
void vectors<_Tp,n>::insert(iterators cur,iterators st,iterators ed)
{
    _Tp* pos=cur.pointer;
    _Tp* s=st.pointer;
    _Tp* e=ed.pointer;
    _Tp* po=p+length-1;
    int len=e-s;
    if((length+=len)>=sizes) p=(_Tp*)realloc(p,sizeof(_Tp)*(sizes+=max(100,len)));
    if(p==NULL) return;
    while(po>=pos)
    {
        *(po+len)=*po;
        po--;
    }
    while(s<e) *(pos++)=*(s++);
}
template <typename _Tp,int n>
typename vectors<_Tp,n>::iterators vectors<_Tp,n>::erase(iterators s)
{
    _Tp* pos=s.pointer;
    _Tp* po=pos+1;
    while(po<p+length)
    {
        *(po-1)=*po;
        po++;
    }
    length--;
    return iterators(pos);
}
template <typename _Tp,int n>
typename vectors<_Tp,n>::iterators vectors<_Tp,n>::erase(iterators st,iterators ed)
{
    _Tp* s=st.pointer;
    _Tp* e=ed.pointer;
    int len=e-s;
    _Tp* po=s+len;
    while(po<p+length)
    {
        *(po-len)=*po;
        po++;
    }
    length-=len;
    return iterators(s);
}
int main()
{
    int x[5]={12,89,2,4,18291};
    vectors<int> a(8);
    a.assign(x,x+5);
    a[5]=7;
    a[6]=42;
    a[7]=9999;
    cout<<a.size()<<endl;
    a.erase(a.begin()+2,a.begin()+4);
    cout<<a.size()<<endl;
    a.insert(a.begin(),5,8);
    cout<<a.size()<<endl;
    a.insert(a.begin()+2,1);
    a.insert(a.end(),3);
    for(vectors<int>::iterators it=a.begin();it!=a.end();it++)
        cout<<*it<<" ";
    cout<<endl;
    return 0;
}