vector内部实现2

push_back 往动态数组的内部进行添加数据

pop_back 往动态数组的尾部进行删除数据

resize  讲元素的数量len改成num个数量  如果size()变大了，多出来的将用默认构造来创建

assert(nullptr);断言函数 可以解决出错问题 和return，throw相似 进行处理异常数据

reserve(int n);如果容器的容量不足扩大容量

maxSize=maxSize+(maxSize>>1)>1?(maxSize>>1):1)  内存不够会发生内存重分配 把原来的内存数据拷贝到新的内存中去

1 2 3 4 6 9 13 19

vector<int>::iterator vit;容器的迭代器

迭代器 是用来遍历容器中部分或者全部容器的对象

结构和类的区分 访问权限不是主要的区分方式 对象中有接口用类 对象里面没有接口就用结构 迭代器用结构来模拟

.h文件不参与编译 只是一个工具

end和begin是指向vertor里面容器的开始和结尾 insert和erase是插入和删除

自己模拟的动态数组在元素删除时不会有内存重分配，但是系统vector在删除时候回导致内存重分配

具体内容由下面实现

 #pragma once
 template<typename T>
 class Myvector
 {
     T *pBuff;//给一个指针用来指向以恶个动态内存
     unsigned int len;//给一个长度 表示这个内存中的元素个数
     size_t maxSize;//存放这个动态数组的内存空间的大小
 public:
     struct MyIterator//这个结构也是一个模板 一个模板内部嵌套定义了一个末班
     {
         T *pIt;
         MyIterator & operator = (MyIterator const& srcIt)
         {
             pIt=srcIt.pIt;
             return *this;
         }
         bool operator!=(MyIterator const& srcIt) const
         {
             return pIt!=srcIt.pIt;
         }
         MyIterator & operator ++ ()//前置
         {
             pIt++;
             return *this;
         }
         MyIterator  operator++ (int)//后置++
         {
             MyIterator tempIt=*this;
             pIt++;
             return tempIt;
         }
         T &operator*()
         {
             return *pIt;
         }
         T &operator-(MyIterator const& scrIt)const
         {
             return pIt-scrIt.pIt;
         }
         MyIterator operator +(int n)
         {
             MyIterator tempIt = *this;
             tempIt.pIt+=n;
             return tempIt;
         }
     };
 public:
     MyIterator begin()//得到容器的第一个位置
     {
         MyIterator tempIt;
         tempIt.pIt=pBuff;
         return templt;
     }
     MyIterator end()//得到容器的最后一个元素的下一个位置
     {
         MyIterator tempIt;
         tempIt.pIt=pBuff+len;
         return tempIt;
     }
 public:
     MyIterator insert(MyIterator const& pos,MyIterator const& firstMyIterator const& second)//插入，在pos处插入n个elem元素
     {
         MyIterator tempIt=pos;
         int n=second-first;
                 for(int i=o;i<n;i++)
             tempIt=insett(templt,*(first+i));//在insert里面调用重载的另一个insert
         return tempIt;
     }
     MyIterator insert(MyIterator const& pos,int n,T const& elem)//插入，在pos处插入n个elem元素
     {
         MyIterator tempIt=pos;
         for(int i=o;i<n;i++)
             tempIt=insett(templt,elem);//在insert里面调用重载的另一个insert
         return tempIt;
     }
     MyIterator insert(MyIterator const& pos,T const& elem)//插入，在pos这个股迭代器所指的位置插入一个elem元素
     {
         int index=pos.pIt-pBuff;//通过迭代器位置和容器的首地址进行相减 得到当前的下标
         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;
         }
         //移位操作
         for(size_t i=len;i>index;--i)
         {
             pBuff[i]=pBuff[i-];
         }
         pBuff[index]=elem;
         len++;
         Myterator tempIt;
         tempIt.pIt=pBuff+index;
         return tempIt;
     }
     //注意：自己模拟的动态数组在元素删除时不会有内存重分配，但是系统vector在删除时候回导致内存重分配
     MyIterator erase(MyIterator const& pos)//删除代码
     {
         int index=pos.pIt-pBuff;
         for(sieze_t i=index;i<len-;i++)
         {
             pBuff[i]=pBuff[i+];
         }
         len--;
         Myterator tempIt;
         tempIt.pIt=pBuff+index;
         return tempIt;
     }
     MyIterator erase(MyIterator const& firstMyIterator const& second)
     {
         int n=second-first;
         MyIterator tempIt=first;
         for(int i=;i<n;++i)
         {
             tempIt=erase(tempIt);
             return tempIt;
         }
     }
 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);//往动态数组的 尾部添加数字
     void pop_back(); //往动态数组的尾部进行删除数据
 public:
     void resize(int num);//讲元素的数量len改成num个数量  如果size()变大了，多出来的将用默认构造来创建
     void resize(int num,const& elem);//resize的重载
     void reserve(int num);//如果容器的容量不足扩大容量
 };

 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;
     }
 }
 template<typename T>
 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;
 }
 template<typename T>
 void Myvector<T>::pop_back()
 {
     --len;
 }
 template<typename T>
 void Myvector<T>::resize(int num)
 {
     if(num<)
     {
         //return;throw
         assert(nullptr);//断言函数
     }
     if(num>len)//num超出扩张空间的时候 通过扩张len的长度 来进行对num的保存
     {
         while(num>=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;
     }
     len=num;
 }
 template<typename T>
 void Myvector<T>::resize(int num,T const& elem)
 {
     if(num<)
     {
         //return;throw
         assert(nullptr);//断言函数
     }
     if(num>len)//num超出扩张空间的时候 通过扩张len的长度 来进行对num的保存
     {
         while(num>=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;
         for(size_t i=len;i<num;++i)
             pBuff[i]=elem;
     }
     len=num;
 }
 template<typename T>
 void Myvector<T>::reserve(int num)
 {
     if(num>maxSize)
     {
         maxSize=num;
         T* tempBuff=new T[maxSize];
         for(size_t i=;i<len;++i)
             tempBuff[i]=pBuff[i];
         if(pBuff!=nullptr)
             delete[] pBuff;
         pBuff=tempBuff;
     }

主函数实现头文件中一些函数的算法

 #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;//调用默认构造

     vector<int> v;
     vector<int>::iterator vit;//迭代器
     for(vit=v.begin();vit!=v.end();++vit)
     {
         printf("%d\n",*vit);
     }

     return ;
 }