简单的 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=0;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<0||a>_size-1)return false;
        else return true;
    }
};
vector::vector(){
    _size=0;
    _capacity=0;
    elems=nullptr;
}
vector::~vector(){
    delete[] elems;
}

vector::vector(int size_):_size(size_),_capacity(size_){
    this->elems=new int[_capacity];
    memset(this->elems,0x3f,_capacity*4);
}
vector::vector(int size_, int e):_size(size_),_capacity(size_){
    this->elems=new int[_capacity];
    for(int i=0;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*4,a.elems,_capacity*4);
}
vector::vector(int *data, int len){
    this->_capacity=len+len/3;
    this->_size=len;
    this->elems=new int[_capacity];
    memset(this->elems,0x3f,_capacity*4);
    memcpy_s(this->elems,_size*4,data,len*4);
}
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*4,a.elems,_capacity*4);
    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*4);
        memcpy_s(es,_size*4,elems,_size*4);
        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++]=-1;
        }
    }else if(size_>this->_capacity){
        this->reserve(size_);
        while(this->_size<this->_capacity){
            this->elems[this->_size++]=-1;
        }
    }
}

int& vector::operator [](int p){
    if(_safePos(p))
    return this->elems[p];
    exit(1);
}
void vector::insert(int pos, int x){
    if(!_safePos(pos))exit(1);
    if(this->_size==this->_capacity){
        reserve(this->_capacity+this->_size/3);
    }
    for(int j=this->_size;j>pos;j--){
        this->elems[j]=this->elems[j-1];
    }
    this->elems[pos-1]=x;
}
void vector::erase(int pos){
    if(!this->_safePos(pos))exit(1);
    for(int i=pos;i<this->_size-1;i++){
        this->elems[i]=this->elems[i+1];
    }
    this->_size-=1;
}
void vector::push_back(int x){
    if(this->_capacity==this->_size){
        this->reserve(this->_capacity+this->_size/3);
        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[0];
}
int& vector::back(){
    return const_cast<int&>(static_cast<const vector*>(this)->back());//这里试试两种不同的写法而已
}
const int& vector::back() const{
    return this->elems[_size-1];
}
bool vector::empty()const{
    return _size==0?true:false;
}