简单的 vector

 #pragma once
 #include <memory.h>
 #include <stdlib.h>
 #include <iostream>
 using std::ostream;
 using std::cout;
 using std::endl;
 class vector{
 public :
     vector();
     ~vector();
     explicit vector(int size_);
     vector(int size_,int e);
     vector(const vector&a);
     vector(int *data,int len);
     vector& operator=(const vector&a);
     vector(vector&&)=delete;
     vector& operator=(vector&&)=delete;

     int size()const;
     int capacity()const;
     void reserve(int capacity_);
     void resize(int size_);
     int& operator[](int);
     void insert(int pos,int x);//insert a new element before the position pos
     void erase(int pos);//erase the element at the position pos;
     void push_back(int x);//insert a new element at the end
     void pop_back();//erase the last element
     int& front();//return the first element
     const int& front()const;
     int& back();//return the last element
     const int& back()const;
     bool empty()const;//true if the size is 0
     friend ostream& operator <<(ostream&os,const vector& a){
         for(int i=;i<a._size;i++){
             cout<<a.elems[i]<<" ";
         }
         cout<<endl;
         return os;
     }

 private:
     int *elems;
     int _size;
     int _capacity;
     bool _safePos(int a)const{
         if(a<||a>_size-)return false;
         else return true;
     }
 };
 vector::vector(){
     _size=;
     _capacity=;
     elems=nullptr;
 }
 vector::~vector(){
     delete[] elems;
 }

 vector::vector(int size_):_size(size_),_capacity(size_){
     this->elems=new int[_capacity];
     memset(this->elems,0x3f,_capacity*);
 }
 vector::vector(int size_, int e):_size(size_),_capacity(size_){
     this->elems=new int[_capacity];
     for(int i=;i<size_;i++){
         this->elems[i]=e;
     }
 }

 vector::vector(const vector &a){
     this->_size=a._size;
     this->_capacity=a._capacity;
     this->elems=new int[_capacity];
     memcpy_s(this->elems,_capacity*,a.elems,_capacity*);
 }
 vector::vector(int *data, int len){
     this->_capacity=len+len/;
     this->_size=len;
     this->elems=new int[_capacity];
     memset(this->elems,0x3f,_capacity*);
     memcpy_s(this->elems,_size*,data,len*);
 }
 vector& vector::operator =(const vector&a){
         if(*this==a) return *this;
         delete[] this->elems;
     this->_size=a._size;
     this->_capacity=a._capacity;
     this->elems=new int[_capacity];
     memcpy_s(this->elems,_capacity*,a.elems,_capacity*);
     return *this;
 }
 int vector::size()const{
     return this->_size;
 }
 int vector::capacity()const{
     return this->_capacity;
 }
 void vector::reserve(int capacity_){
     if(capacity_<=this->_capacity)return;
     else{
         this->_capacity=capacity_;
         int *es=new int[_capacity];
         memset(es,0x3f,_capacity*);
         memcpy_s(es,_size*,elems,_size*);
         delete[] elems;
         this->elems=es;
     }
 }
 void vector::resize(int size_){
     if(size_<this->_size)this->_size=size_;
     else if(size_<=this->_capacity){
         while(this->_size<size_){
             this->elems[this->_size++]=-;
         }
     }else if(size_>this->_capacity){
         this->reserve(size_);
         while(this->_size<this->_capacity){
             this->elems[this->_size++]=-;
         }
     }
 }

 int& vector::operator [](int p){
     if(_safePos(p))
     return this->elems[p];
     exit();
 }
 void vector::insert(int pos, int x){
     if(!_safePos(pos))exit();
     if(this->_size==this->_capacity){
         reserve(this->_capacity+this->_size/);
     }
     for(int j=this->_size;j>pos;j--){
         this->elems[j]=this->elems[j-];
     }
     this->elems[pos-]=x;
 }
 void vector::erase(int pos){
     if(!this->_safePos(pos))exit();
     for(int i=pos;i<this->_size-;i++){
         this->elems[i]=this->elems[i+];
     }
     this->_size-=;
 }
 void vector::push_back(int x){
     if(this->_capacity==this->_size){
         this->reserve(this->_capacity+this->_size/);
         this->elems[this->_size++]=x;
     }else{
         this->elems[this->_size++]=x;
     }
 }
 void vector::pop_back(){
     if(!this->empty())
         --this->_size;
 }
 int& vector::front(){
     return const_cast<int&>(static_cast<const vector&>(*this).front());//把指针转成const型，调用下面一个。再将结果的转成非const
 }
 const int& vector::front() const{
     return this->elems[];
 }
 int& vector::back(){
     return const_cast<int&>(static_cast<const vector*>(this)->back());//这里试试两种不同的写法而已
 }
 const int& vector::back() const{
     return this->elems[_size-];
 }
 bool vector::empty()const{
     return _size==?true:false;
 }