vector 容器内部的实现（数组）具体实现参考boost库在另一篇文章

#include <iostream>  
#include <vector>  
#include <functional>//函数对像  
#include <string>  
#include <algorithm>  
#include <time.h>  
using namespace std;  
  
using namespace std;  
template<typename t>  
class vector  
{  
public:  
  vector() :mpvec(null),msize(0),mcur(0)  
  {}  
  vector(int size, const t &val=t())  
  {  
              mpvec=new t [size];  
              msize=size;  
              mcur=0;  
              for(int i=0;i<size;i++)  
              {  
                  mpvec[i]=val;  
              }  
  }  
  vector(const vector<t> &src)  
  {  
      mpvec =new t[src.msize];  
      memcpy(mpvec,src.mpvec,sizeof(t)*src.msize);  
      msize=src.msize;  
      mcur=src.mcur;  
  }  
  vector<t>& operator=(const vector<t> &src)  
  {  
      if(this ==&src)  
      {  
          return *this;  
      }  
      delete [] mpvec;  
      mpvec =new t[src.msize];  
      memcpy(mpvec,src.mpvec,sizeof(t)*src.msize);  
      msize=src.msize;  
      mcur=src.mcur;  
      return *this;  
  }  
  ~vector()  
  {  
      delete []mpvec;  
  }  
  
  t& operator[](int index)  
  {  
      if(index <0||index>msize-1)  
      {  
          throw "erro";  
      }  
      return mpvec[index];  
  }  
  const t& operator[](int index)const  
  {  
      if(index <0||index>msize-1)  
      {  
          throw "erro";  
      }  
      reutrn mpvec[index];  
  }  
  void push_back(const t &val)  
  {  
      if(full())  
      {  
          resize(msize*2);  
      }  
      mpvec[mcur++]=val;  
  }  
  void pop_back()  
  {  
      if(empty())  
      {  
          return ;  
      }  
      mcur--;  
  }  
  void reserve(int size)  
  {  
      if(msize==0)  
      {  
          mpvec=new t[size];  
          msize=size;  
        
          mcur=0;  
      }  
      else  
      {  
          t *tmp=new t[size+msize]();  
          memcpy(tmp,mpvec,sizeof(t)*msize);  
          delete []mpvec;  
          msize+=size;  
          mpvec=tmp;  
      }  
  
  }  
  int size()const  
  {  
      return msize;  
  }  
  bool empty()  
  {  
      return mcur==0;  
  
  }  
  bool full()const  
  {  
      return mcur==msize;  
  }  
  void resize(int size)  
  {  
      if(size==0)          
      {  
          mpvec=new t[1];  
          msize=1;  
      }  
      else  
      {  
          t *ptmp=new t[size];  
          memcpy(ptmp,mpvec,sizeof(t)*mcur);  
          msize=size;  
          delete []mpvec;  
          mpvec=ptmp;  
      }  
  }  
  
  class iterator  
  {  
              public:  
              typedef t value_type;  
              iterator(t* p=null)  
              {  
                  mp=p;  
              }  
              iterator& operator ++(int)  
              {  
                  mp++;  
                  return *this;  
              }  
              t& operator*(){return *mp;}  
              iterator operator+(int t2)  
              {  
                  return iterator(mp+t2);           
              }  
              iterator operator-(int t2)  
              {  
                  return iterator(mp-t2);   
              }     
              bool operator<(const iterator &src)  
              {  
                  if(mp<src.mp)  
                  {  
                      return true;  
                  }  
                  return false;  
              }  
              bool operator!=(const iterator &src)  
              {  
                  if(src.mp!=mp)  
                  {  
                      return true;  
                  }  
                  return false;  
              }  
          private:  
              t *mp;  
                
            
  
  };  
  iterator begin()  
  {  
      return iterator(mpvec);  
  }  
  iterator end()  
  {  
      return iterator(mpvec+mcur);  
  }  
  private:  
  t *mpvec;  
  int msize;  
  int mcur;  
};