vector内部的实现1

写vector的内部方法

#include<vector>
using std::vector;
//写一个动态内存

class CA{
    int a;
public:
    CA(int i){ i = a; }
    CA();
};
template <class T>
class CStack
{
    T pBuff[10];
public:
    CStack();
    ~CStack();
    void push(T const& val);//入栈
    void pop();//出栈
    T GetTop();//得到栈顶的元素
};
template <class T>
void CStack<T>::pop()
{
    top--;
}

template <class T>
CStack<T>::CStack()
{
    top = 0;
}

template <class T>
void CStack<T>::push(T const& val)
{
    pBuff[top++] = val;
}
int main()
{
    CA a(1);//调用带参构造
    CA pa[10];//调用默认构造  数组不可以用带参构造来构造
    CA *pa1 = new CA;//调用默认构造

    return 0;
}

写一个字节的类对自己的类进行加工封装函数 实现vector内部封装的效果 进而实现所需要的内容

#pragma once
template<typename T>
class Myvector
{
    T *pBuff;//给一个指针用来指向以恶个动态内存
    unsigned int len;//给一个长度 表示这个内存中的元素个数
    size_t maxSize;//存放这个动态数组的内存空间的大小
public:
    Myvector();//默认构造
    Myvector(int n);//有n个T的默认构造对象 构造进这个容器
    Myvector(int n,T const& elem);//用n个elem对象 构造进这个容器
    Myvector(Myvector const& other);//深拷贝
    //Myvector();

    ~Myvector();//析构函数 释放所有的对象 也会将变量删除（堆内存和栈内存）
    void clear();//清除 （删除堆内存里数据）
public:
    size_t size() const;
    size_t capacit() const;//返回容器代下
    bool empty() const;//判断容器是否为空
public:
    bool operator==(Myvector const& srcVector) const;//运算符重载==
    bool operator!=(Myvector const& srcVector) const; //重载运算符!=
public:
    void assgin(int n, T const& elem);//赋值
    void swap(Myvector & srcVerctor);//交换
public:
    T at(int index);//返回动态数组下标为index的元素 是c++中唯一会主动抛异常的函数
    T operator[](int index);//重载[]运算符
    T front();//得到容器中的第一个元素，不管容器为不为空
    T back();
public:
    void push_back(T const& elem);//往动态数组的 尾部添加数字
};
template<typename T>
void Myvector<T>::Myvector()//无参构造
{
    pBuff = nullptr;
    len = 0;
    maxSize = 0;
}

template<typename T>
void Myvector<T>::~Myvector()//析构函数 清除对象
{
    clear();//调用clear函数 重复代码通过封装函数来提高代码的效率
}
template<typename T>
void Myvector<T>::clear
{
    if (pBuff != nullptr)
    {
        delete[] pBuff;
        pBuff = nullptr;
        len = 0;
        maxSize = 0;
    }
}
template<typename T>
void Myvector<T>::Myvector(int n)//n个有T的默认构造的构造对象 构造进这个容器
{//n个对象构造这个容器
    if (n < 0)
    {
        pBuff = nullptr;
        len = 0;
        maxSize = 0;
    }
    else
    {
        len = maxSize = n;
        pBuff = new T[maxSize];
    }
}

template<typename T>
void Myvector<T>::Myvector(int n, T const& elem)//用n个elem对象来构造这个容器  &来增加传递效率
{
    if (n < 0)
    {
        pBuff = nullptr;
        len = 0;
        maxSize = 0;
    }
    else
    {
        len = maxSize = n;
        pBuff[i] = new T[maxSize];
        for (size_t i = 0; i < len; ++i)//size_t无符号的int
        {
            pBuff[i] = elem;
        }
    }
}
template<typename T>
void Myvector<T>::Myvector(Myvector const& other)
{
    len = other.len;
    maxSize = other.maxSize;
    pBuff = nullptr;
    if (len > 0)
    {
        pBuff = new T[maxSize];
        for (int i = 0; i < len; ++i)
            pBuff[i] = other.pBuff[i];
    }
}
template<typename T>
size_t Myvector<T>::size() const//返回容器的长度
{
    return len;
}
template<typename T>
size_t Myvector<T>::capacity() const//返回容器大小
{
    return maxSize;
}
template<typename T>
bool Myvector<T>::empty() const//判断容器是否为空
{
    //return pBuff == nullptr;泵使用这一种 这一种判定存不存在
    return len == 0;//是否为0 0是空的
}
template<typename T>
bool Myvector<T>::operator==(Myvector const& srcVector) const//判断容器是不是相等
{
    if (len != srcVector.len)//长度不等
        return false;
    for (size_t i = 0; i < len; ++i)//遍历判定内容是否相等
    {
        if (pBuff[i] != srcVector.pBuff[i])
            return false;
    }
    return true;
}
template<typename T>
bool Myvector<T>::operator==(Myvector const& srcVector) const//判断容器是不是相等
{
    return !(*this == srcVector);
}
template<typename T>
void Myvector<T>::assign(int n, T const& elem)//和带参构造类似 对容器进行赋值
{
    clear();//重点：清除自身可能原有的动态内存
    if (n > 0)
    {
        len = maxSize = n;
        pBuff = new T[maxSize];
        for (size_t i = 0; i < len; ++i)
            pBuff[i] = elem;
    }
}

void Myvector<T>::swap(Myvector & srcVector)
{
    T *tempBuff = pBuff;
    size_t tempLen = len;
    size_t tempMaxSize = maxSize;//定义三个变量

    pBuff = srcVector.pBuff;
    len = srcVector.len;
    maxSize = srcVector.maxSize;//数据的交换

    srcVector.pBuff = tempBuff;
    srcVector.len = tempLen;
    srcVector.maxSize = tempMaxSize;
}
template<typename T>
T CMyVector<T>::at(int index)//唯一的会主动抛异常的函数
{
    if (index < 0 || index >= len)
        throw "out_of_range";//防止越界 抛异常
    return pBuff[index];
}

template<typename T>
T CMyVector<T>::operator[](int index)//这个应该出错就出错 无法出来 按照给的要求来
{
    return pBuff[index];
}
template<typename T>
T Myvector<T>::back()
{
    return pBuff[len - 1];
}

template<typename T>
T Myvector<T>::front()
{
    return pBuff[0];
}

template<typename T>
T Myvector<T>::operator[](int index)
{
    return pBuff[index];
}
template<typename T>
void Myvector<T>::push_back(T const& elem)
{
    //1 2 3 4 6 9 13 19
    if (len >= maxSize)
    {
        maxSize = maxSize + ((maxSize >> 1) > 1 ? (maxSize >> 1) : 1);
        T *tempBuff = new T[maxSize];
        for (size_t i = 0; i < len; ++i)
            tempBuff[i] = pBuff[i];
        if (pBuff != nullptr)
            delete[] pBuff;
        pBuff = tempBuff;
    }
    pBuff[len++] = elem;
}