C++ --- Day05

vector 实现。有错误，没复刻 

#include <iostream>
#include<string.h>
using namespace std;
template <class T>
class Myvector
{
public:
    //无参构造
    Myvector()
    {
        vec_arr = nullptr;
        last = nullptr;
        end = nullptr;

    }
    //有参构造
    Myvector(int size)
    {
        vec_arr = new T[size];
        end = vec_arr + size;
        last = end;
        memset(vec_arr,0,sizeof (int)*size);

    }
    Myvector(int size , T elem)
    {
        vec_arr = new T[size];
        end = vec_arr + size;
        last = end;
        int i = 0;
        while(vec_arr+i != end)
        {
            *(vec_arr+i) = elem;
            i++;
        }
    }
    //拷贝构造
    Myvector(const Myvector &mvt)
    {
        if(vec_arr==mvt.vec_arr){}
        else if(mvt.vec_arr == nullptr)
        {
            vec_arr = nullptr;
            end = nullptr;
            last = nullptr;
        }
        else
        {
            int len = mvt.end - mvt.vec_arr;
            vec_arr = new T[len];
            for(int i = 0; i < len;i++)
            {

                *(vec_arr + i) = *(mvt.vec_arr + i);
            }
            last = vec_arr + (mvt.last-mvt.vec_arr);
            end = vec_arr + (mvt.end-mvt.vec_arr);
        }
    }
    //析构
    ~Myvector()
    {
        if(vec_arr != nullptr)
        {
            delete [] vec_arr;
        }
    }
    //拷贝赋值
    Myvector& operator=(const Myvector& mvt);
    //改变容器中可存储元素的个数
    void resize( int new_size );
    //将值赋给容器
    void assign(int num , T elem);
    //访问指定的元素，同时进行越界检查
    T& at(int pos);
    //访问指定的元素,[]重载
    T& operator[](int pos);
    //访问第一个元素  到首元素的引用
    T& front() const;
    //访问最后一个元素  到尾元素的引用
    T& back() const;
    //返回指向内存中数组第一个元素的指针
    const T* data()const;
    //检查容器是否为空
    bool empty() const;
    //返回元素个数
    int size() const;
    //返回当前存储空间能够容纳的元素数
    int capacity() const;
    //预留存储空间
    void reserve( int new_cap );
    //插入元素
    void insert( int pos, const T& elem );
    //清除内容
    void clear();
    //将元素添加到容器末尾
    void push_back( const T& elem );
    //移除末元素
    void pop_back();
public:
    T *vec_arr;//首地址
    T *last;//有效元素后一位
    T *end;//最后一位后一位
};
int main()
{
    cout<<"无参构造："<<endl;
    cout<<" assign："<<endl;
    Myvector<int> v1;
    v1.assign(5,1);
    for(int i = 0;i<5;i++)
        cout<<v1.at(i)<<" ";
    cout<<endl;
    cout<<" 用at()更改下标为2的元素为8："<<endl;
    v1.at(2) = 8;
    for(int i = 0;i<5;i++)
        cout<<v1.at(i)<<" ";
    cout<<endl;
    cout<<" 用[]更改下标为3的元素为9："<<endl;
    v1[3] = 9;
    for(int i = 0;i<5;i++)
        cout<<v1.at(i)<<" ";
    cout<<endl;

    cout<<"-------------------"<<endl;
    cout<<"有参构造："<<endl;
    Myvector<int> v2(5,4);
    for(int i = 0;i<5;i++)
        v2.at(i) = i ;
    for(int i = 0;i<5;i++)
        cout<<v2.at(i)<<" ";
    cout<<endl;
    //访问第一个元素  到首元素的引用
    cout<<v2.front()<<endl;
    //访问最后一个元素  到尾元素的引用
    cout<<v2.back()<<endl;
    //返回指向内存中数组第一个元素的指针
    cout<<v2.data()<<endl;
    //返回元素个数
    cout<<v2.size()<<endl;
    //返回当前存储空间能够容纳的元素数
    cout<<v2.capacity()<<endl;
    cout<<"-------------------"<<endl;
    cout<<"拷贝构造："<<endl;
    Myvector<int> v3(v2);
    //清除内容
    v3.clear();
    //预留存储空间
    v3.reserve(50);
    cout<<"v3.capacity:"<<v3.capacity()<<endl;
    //插入元素
    v3.insert(0,1);
    cout<<"v3的元素个数："<<v3.size()<<endl;
    cout<<"v3首元素："<<v3.front()<<endl;
    //将元素添加到容器末尾
    v3.push_back(10);
    for(int i = 0;i<v3.size();i++)
        cout<<v3.at(i)<<" ";
    cout<<endl;

    cout<<v3.size()<<endl;
    //移除末元素
    v3.pop_back();
    for(int i = 0;i<v3.size();i++)
        cout<<v3.at(i)<<" ";
    cout<<endl;

    return 0;
}

//拷贝赋值
template<class T>
Myvector<T>& Myvector<T>::operator=(const Myvector<T>& mvt)
{
    if(this->vec_arr == mvt.vec_arr){}
    else
    {
        int len = mvt.end - mvt.vec_arr;
        if(vec_arr != nullptr)
            delete []vec_arr;
        vec_arr = new T[len];
        for(int i = 0; i < len;i++)
        {
            *(vec_arr + i) = *(mvt.vec_arr + i);
        }
        last = vec_arr + (mvt.last-mvt.vec_arr);
        end = vec_arr + (mvt.end-mvt.vec_arr);
    }
    return *this;

}
//改变容器中可存储元素的个数
template<class T>
void Myvector<T>::resize( int new_size )
{
    int len = last-vec_arr;
    if(vec_arr != nullptr)
    {
        T* p = vec_arr;
        if(len < new_size)
        {
            this->vec_arr = new T[new_size];
            last = vec_arr;
        }
        for(int i=0;i<len-1;i++)
        {
            *(vec_arr + i) = *(p + i);
        }
        delete [] p;
        end = vec_arr + new_size;
        last = end;
    }
    else
    {
        this->vec_arr = new T[new_size];
        last = vec_arr;
        end = vec_arr + new_size;
    }
}
//将值赋给容器
template<class T>
void Myvector<T>::assign(int num , T elem)
{
    int len = end-vec_arr;
    if(len == 0)
    {
        vec_arr = new T[num];
        last = vec_arr;
        end = vec_arr + num;
        while(last != end)
            *(last++) = elem;
    }
    else
    {
        while(num > len)
        {
            len = len * 2;
        }
        this->resize(len);
        for(int i = 0;i<num;i++)
            *(vec_arr+i) = elem;
        end = vec_arr + len;
        last = vec_arr + num;
    }

}
//访问指定的元素，同时进行越界检查
template<class T>
T& Myvector<T>::at(int pos)
{

    int len = last - vec_arr;
    if(pos < 0 || pos >= len)
    {
        throw int(-1);
    }
    return *(vec_arr + pos);
}

//访问指定的元素,[]重载
template<class T>
T& Myvector<T>::operator[](int pos)
{
    int len = last - vec_arr;
    if(pos < 0 || pos >= len)
    {
        throw int(-1);
    }
    return *(vec_arr + pos);
}

//访问第一个元素  到首元素的引用
template<class T>
T& Myvector<T>::front() const
{
    int len = last - vec_arr;
    if(len == 0)
    {
        throw int(-1);
    }
    return *(vec_arr);
}

//访问最后一个元素  到尾元素的引用
template<class T>
T& Myvector<T>::back() const
{
    return *(last-1);
}

//返回指向内存中数组第一个元素的指针
template<class T>
const T* Myvector<T>::data()const
{
    return vec_arr;
}
//检查容器是否为空
template<class T>
bool Myvector<T>::empty() const
{
    if(last == vec_arr)
        return true;
    return false;
}

//返回容纳的元素数
template<class T>
int Myvector<T>::size() const
{
    return last - vec_arr;
}

//返回当前存储空间能够容纳的元素数
template<class T>
int Myvector<T>::capacity() const
{
    return end - vec_arr;
}

//预留存储空间
template<class T>
void Myvector<T>::reserve( int new_cap )
{
    if(new_cap >=0)
    {
        vec_arr = new T[new_cap];
        last = vec_arr;
        end = vec_arr + new_cap;
    }
}
//插入元素
template<class T>
void Myvector<T>::insert( int pos, const T& elem )
{
    int len = last - vec_arr;
    if(pos < 0 || pos >len)
    {
        throw int(-1);
    }
    if(last == end)
    {
        this->resize(len*2);
        T* p = end;
        for(int i = 0 ; i < len-pos;i++)
        {
            *p = *(p-1);
            p--;
        }
        *p = elem;
        last++;
    }
    else if(len==0)
    {
        this->resize(1);
        *vec_arr = elem;
    }

}
//清除内容
template<class T>
void Myvector<T>::clear()
{
    last = vec_arr;
}
//将元素添加到容器末尾
template<class T>
void Myvector<T>::push_back( const T& elem )
{
    int len = last - vec_arr;
    if(last == end)
        this->resize(len*2);
    *last = elem;
    last++;
}
//移除末元素
template<class T>
void Myvector<T>::pop_back()
{
    if(this->empty())
        throw int(-2);
    last--;
}