模拟实现vector之进阶篇

最新推荐文章于 2025-05-21 20:59:02 发布

困得睁不开眼

最新推荐文章于 2025-05-21 20:59:02 发布

阅读量717

点赞数

CC 4.0 BY-SA版权

分类专栏： C、C ++ 文章标签：模拟实现vector之进阶篇 iterator

本文链接：https://blog.youkuaiyun.com/Misszhoudandan/article/details/80723382

C、C ++ 专栏收录该内容

35 篇文章

订阅专栏

本文介绍了一个自定义Vector类的实现，重点在于迭代器功能的模拟实现。文章通过具体的代码示例展示了如何进行基本操作如push_back、pop_back等，并详细解释了迭代器的使用方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

之前我们实现了一些基本的vector的实现vector基本实现
今天我们在之前的基础上，；模拟实现实现vector中的迭代器
之前写过有关库里面的vector是如何使用的：
链接一：vector基本功能的实现
链接二：vector中扩容函数区别

代码大军如下：

my_vector.cpp

#include <stdio.h>
#include <assert.h>
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

//模拟实现vector
template <class T>
class MyVector
{
  public:
    typedef T* Iterator;//用原生指针 类型重定义为 Iterator迭代器 
    typedef const T* const_Iterator;
    MyVector():_start(NULL),_finish(NULL),_end_of_storage(NULL)
    {}
    ~MyVector()
    {
      delete []_start;
      _start=_finish=_end_of_storage=NULL;
    }

    void  PushBack(const T & val)
    {
      //容量不够时就需要扩容
      if(_finish>=_end_of_storage)
      {
        Expand(Capacity()*2+1);
      }
      *_finish=val;
      _finish++;
    }
    void PopBack()
    {
      if(Size()==0)//表示顺序表为空
      {
        return;
      }
      else
      {
        _finish--;
      }
    }
    //*****************对顺序表进行扩容并初始化************************
    void Resize(size_t n ,const T & val=T())
    {
      if(n>Size())
      {
          if(n>Capacity())
          {
            //需要进行扩容
            Expand(n);
          }
          //上面进行扩容后。只是改变了容量
          //并没有改变size
          //然后对size和n之间的元素进行初始化
          //所以要手动的将_finish修改到正确的位置，这样才能保证下面的赋值操作正常进行，否则会段错误的
          _finish=_start+n;
          size_t i=0;
          for(i=Size();i<n;++i)
          {
            _start[i]=val;
          }
      }
      else
      {
        //如果n小于size
        _finish=_start+n;
        //将size减小
      }
    }


    //*****************对顺序表进行赋值************************
    void Assign(size_t n,const T &val= T())
    {
      if(n>Size())
      {
        if(n>Capacity())
        {
          Expand(n);
        }
        _finish=_start+n;
      }
      size_t i=0;
      for(i=0;i<n;++i)
      {
        _start[i]=val;
      }
    }

    //*****************对顺序表进行扩容************************
    void Reserve(size_t n)
    {
      if(n<=Capacity())
      {
        return;
      }
      else
      {
        Expand(n);
      }
    }

    //********************对顺序表进行插入***********************
    //********************对顺序表进行插入***********************                                                                                            
    Iterator Insert(const Iterator & pos,const T & val)                                                                                                      
    {                                                                                                                                                        
      assert(pos<=end());//可以进行尾插                                                                                                                      
      int gap=pos-begin();//这里要将pos的位置保存下来                                                                                                       
      //因为如果进行扩容的话pos的位置已经变了                                                                                                                
      if(_finish==_end_of_storage)                                                                                                                           
      {                                                                                                                                                      
        Expand(Capacity()*2+1);                                                                                                                              
      }                                                                                                                                                      
      pos=begin()+gap;                                                                                                                                       
      _finish++;                                                                                                                                             
      size_t i=0;                                                                                                                                            
      for(i=Size();i>pos-begin();--i)                                                                                                                        
      {                                                                                                                                                      
        _start[i]=_start[i-1];                                                                                                                               
      }                                                                                                                                                      
      *pos=val;                                                                                                                                              
    }                            
    //**********************对顺序表进行删除***********************

    Iterator Erase(const Iterator& pos)
    {
      assert(pos<end());

      Iterator cur=pos;
      while(cur<end()-1)
      {
        *cur=*(cur+1);
        cur++;
      }
      _finish--;
    }


    T& operator[](size_t pos)
    {
      assert(pos<Size());
      return _start[pos];
    }
    const T& operator[](size_t pos)const
    {
      assert(pos<Size());
      return _start[pos];
    }
    //****迭代器的接口
    Iterator begin()
    {
      return _start;
    }

    Iterator end()
    {
      return _finish;
    }
    const_Iterator begin() const
    {
      return _start;
    }

    const_Iterator end()  const
    {
      return _finish;
    }
    size_t Size()
    {
      return _finish-_start;
    }
    size_t Capacity()
    {
      return _end_of_storage-_start;
    }

  protected:
    Iterator _start;
    Iterator _finish;
    Iterator _end_of_storage;


    void Expand(size_t n)
    {
      if(n<=Capacity())
      {
        return;
      }
      else
      {
        size_t Size=this->Size();
        //注意这里要将Size()先保存下。
        //因为下面在新开的空间后再进行赋值时用到
        T * new_start=new T[n];
        size_t  i=0;
        //对新开的空间进行赋值。
        //这里不用memcpy()是因为T 的如果是自定义类型的话，存在深浅拷贝的问题
        for(i=0;i<Size;i++)
        {
          new_start[i]=_start[i];
        }
        //释放旧的空间
        delete [] _start;
        _start=NULL;

        //修改新空间的三个指针
        _start=new_start;
        _finish=_start+Size;//这里就不可以用Size()函数来求取Size 因为start位置已经变了
        _end_of_storage=_start+n;
      }
    }
};

mian.cpp

#include "my_vector.cpp"

//实现一个打印MyVector的函数
void PrintMyVector(const MyVector<int>& con)
{
  MyVector<int>::const_Iterator  it =con.begin();
  //因为在打印函数中不会修改容器的内容，用const 参数接收
  //那么迭代器也应该是const 的，还要实现了const的begin()和end();
  while(it!=con.end())
  {
    cout<<*it<<" ";
    it++;
  }
  cout<<endl;
}

void test1()
{
  MyVector<int> v1;
  v1.PushBack(1);
  v1.PushBack(2);
  v1.PushBack(3);
  v1.PushBack(4);
  v1.PushBack(5);

  PrintMyVector(v1);
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

  v1.PopBack();
  v1.PopBack();
  PrintMyVector(v1);
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

  v1.Resize(12,8);
  PrintMyVector(v1);
  printf("Resize()会改变size,并且进行初始化\n");
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

  v1.Resize(3);
  PrintMyVector(v1);
  printf("Resize()会缩小size,但不会改变capacity()\n");
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

  v1.Reserve(20);
  PrintMyVector(v1);
  printf("Reserve只会改变capacity()\n");
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

  v1.Reserve(4);
  PrintMyVector(v1);
  printf("Reserve不会缩小容量\n");
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

  v1.Assign(3,6);
  PrintMyVector(v1);
  printf("Assign对容器进行赋值\n");
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

  v1.Assign(23,9);
  PrintMyVector(v1);
  printf("Assign会进行扩容，并且会进行多所有元素进行赋值\n");
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

}

void test2()
{
  MyVector<int> v1;
  v1.PushBack(1);
  v1.PushBack(2);
  v1.PushBack(3);
  v1.PushBack(4);
  v1.PushBack(5);

  PrintMyVector(v1);
  cout<<"Size:"<<v1.Size()<<endl;
  cout<<"Capacity:"<<v1.Capacity()<<endl;

  v1.Insert(v1.begin()+2,9);
  PrintMyVector(v1);

  v1.Insert(v1.begin()+4,12);
  PrintMyVector(v1);

  v1.Erase(v1.begin()+4);
  PrintMyVector(v1);

  v1.Erase(v1.begin()+2);
  PrintMyVector(v1);


}

int main()
{
  test1();
  test2();
  return 0;
}

执行结果
这里写图片描述