C ++ 面试 手撕 vector 构造、析构、赋值、拷贝、空间分配器实现

C++ vector 构造、析构、赋值、拷贝、右值赋值、右值拷贝、空间分配器实现

#include<bits/stdc++.h>
using namespace std;
template<typename T>
class Allocator{
public :
    //开辟释放内存
    T* allocate(int size){
        return (T*)malloc(sizeof(T)*size);
    }
    T*deallocate(T* p){
        free(p);
    }
    //构造析构
    void construct(T*p,const T &val){
        new (p)T(val);//定位new
    }
    void destory(T*p){
        p->~T();//调用析构函数
    }
};
template<typename T,typename Alloc=Allocator<T> >
class vvecotr{
public :
    //构造函数
    vvecotr(int size=20){//多少个元素。
        alloc = new Allocator<T>();
        _begin = alloc->allocate(size);//开辟多少个内存
        _end = _begin+size;
        _now = _begin; 
    }
    //析构函数
    ~vvecotr(){
        free(_begin);
        delete alloc;
    }
    //拷贝构造函数
    vvecotr(const vvecotr<T>&vec){//拷贝构造函数
        alloc = new Allocator<T>();
        int size = vec._end-vec._begin;
        _begin = alloc->allocate(size);
        _end = _begin+size;
        _now=_begin;

        T *p=vec._begin;
        for(;p!=vec._now;p++,_now++){
            alloc->construct(_now,*p);
        }
    }
    //拷贝赋值构造函数
    vvecotr& operator=(const vvecotr<T>&vec){
        if(this==&vec)return *this;
        
        alloc->deallocate(_begin);

        alloc = new Allocator<T>();
        int size = vec._end-vec._begin;
        _begin = alloc->allocate(size);
        _end = _begin+size;
        _now=_begin;

        T *p=vec._begin;
        for(;p!=vec._now;p++,_now++){
            alloc->construct(_now,*p);
        }

        return *this;
    }
    
    vvecotr( vvecotr<T>&&vec){
        cout<<"vvecotr( vvecotr<T>&&vec){"<<endl;
        alloc = vec.alloc;
        _begin=vec._begin;
        _now = vec._now;
        _end = vec._end;
        vec._begin=vec._end=vec._now=nullptr;
        vec.alloc=nullptr;
    }
    vvecotr & operator=( vvecotr<T>&&vec){
        //不会出现自赋值
        alloc = vec.alloc;
        _begin=vec._begin;
        _now = vec._now;
        _end = vec._end;
        vec._begin=vec._end=vec._now=nullptr;
        vec.alloc=nullptr;

        return *this;
    }
   
    void push_back(const T&val){
        if(_now==_end){
            resize();
        }
        alloc->construct(_now,val);
        _now++;
    }
    void pop_back(){
        if(_now != _begin){
            alloc->destory(_now--);
        }
    }
    T& operator[](int index){
     
        return _begin[index];
    }
    bool empty(){
        return _now==_begin;
    }
    int size(){
        return _now-_begin;
    }
    void show(){
        T*p =_begin;
        while(p!=_now){
            cout<< *p <<" ";
            p++;
        }
        cout<<endl;
    }
private:
    T* _begin ;
    T* _now;
    T* _end;
    Alloc *alloc;

    void resize(){
        int size=_end-_begin;
        T *p=alloc->allocate(size*2);
        for(int i=0;i<size;i++){
            p[i]=_begin[i];
        }
        alloc->deallocate(_begin);
        _begin = p;
        _now=p+size;
        _end=p+size*2;
    }
};

vvecotr<int> get(){
    vvecotr<int>vec(50);
    for(int i=0;i<=5;i++)vec.push_back(i);
    return vec;   
}
int main(){
    vvecotr<int>vec(50);
    for(int i=0;i<=15;i++)vec.push_back(i);
    vec.show();
   
    

    //测试右值拷贝构造
    // vvecotr<int> a = std::move(vec);
    // cout<<a.size()<<endl;

    //测试右值拷贝赋值
    // vvecotr<int>a;
    // a=get();
    // a.show();
    return 0;
}