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[];

 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 = ;

 }

 template <class T>

 void CStack<T>::push(T const& val)

 {

     pBuff[top++] = val;

 }

 int main()

 {

     CA a();//调用带参构造

     CA pa[];//调用默认构造  数组不可以用带参构造来构造

     CA *pa1 = new CA;//调用默认构造

     return ;

 }

写一个字节的类对自己的类进行加工封装函数实现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 = ;

     maxSize = ;

 }

 template<typename T>

 void Myvector<T>::~Myvector()//析构函数 清除对象

 {

     clear();//调用clear函数 重复代码通过封装函数来提高代码的效率

 }

 template<typename T>

 void Myvector<T>::clear

 {

     if (pBuff != nullptr)

     {

         delete[] pBuff;

         pBuff = nullptr;

         len = ;

         maxSize = ;

     }

 }

 template<typename T>

 void Myvector<T>::Myvector(int n)//n个有T的默认构造的构造对象 构造进这个容器

 {//n个对象构造这个容器

     if (n < )

     {

         pBuff = nullptr;

         len = ;

         maxSize = ;

     }

     else

     {

         len = maxSize = n;

         pBuff = new T[maxSize];

     }

 }

 template<typename T>

 void Myvector<T>::Myvector(int n, T const& elem)//用n个elem对象来构造这个容器  &来增加传递效率

 {

     if (n < )

     {

         pBuff = nullptr;

         len = ;

         maxSize = ;

     }

     else

     {

         len = maxSize = n;

         pBuff[i] = new T[maxSize];

         for (size_t i = ; 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 > )

     {

         pBuff = new T[maxSize];

         for (int i = ; 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是空的

 }

 template<typename T>

 bool Myvector<T>::operator==(Myvector const& srcVector) const//判断容器是不是相等

 {

     if (len != srcVector.len)//长度不等

         return false;

     for (size_t i = ; 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 > )

     {

         len = maxSize = n;

         pBuff = new T[maxSize];

         for (size_t i = ; 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 <  || 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 - ];

 }

 template<typename T>

 T Myvector<T>::front()

 {

     return pBuff[];

 }

 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 >> ) >  ? (maxSize >> ) : );

         T *tempBuff = new T[maxSize];

         for (size_t i = ; i < len; ++i)

             tempBuff[i] = pBuff[i];

         if (pBuff != nullptr)

             delete[] pBuff;

         pBuff = tempBuff;

     }

     pBuff[len++] = elem;

 }

巴特西

vector内部的实现1

最新文章

热门文章