C++初阶学习第九弹——探索STL奥秘(四)——vector的深层挖掘和模拟实现

简介: C++初阶学习第九弹——探索STL奥秘(四)——vector的深层挖掘和模拟实现

前言:

在前面我们已经学习了string的使用及其模拟实现,并且我们也已经学习了vector的使用,今天我们就来学习一下vector的模拟实现


一、 vector的基本成员变量

我们之前已经学习了vector的使用,所以也基本了解了其机制,现在我们来看一下vector工作的基本机制

从图中我们可以看出,vector的操作机制实际上是通过三个指针来实现的:

_start、_finish、_endOfStorage

所以vector的基本成员变量为:

#include<iostream>
using namespace std;
//命名一个命名空间,在这个命名空间中实现我们自己的vector,这样能避免受库中vector的影响
namespace zda
{
  template<class T>
  class vector
  {
  privated:
    T* _start;      //指向有效数据的头
    T* _finish;     //指向有效数据的尾
    T* _endOfStorage;    //指向容量的尾
  };
}

因为vector的本质上与顺序表很相似,只是存储的数据上变的更加多元化了,所以我们可以对基本成员做一些调整,将其改成迭代器相关的,方便我们后面写类成员函数

改进后:

#include<iostream>
using namespace std;
//命名一个命名空间,在这个命名空间中实现我们自己的vector,这样能避免受库中vector的影响
namespace zda
{
  template<class T>
  class vector
  {
  public:
    // Vector的迭代器是一个原生指针
    typedef T* iterator;
    typedef const T* const_iterator;
 
  privated:
    iterator _start;      //指向有效数据的头
    iterator _finish;     //指向有效数据的尾
    iterator _endOfStorage;    //指向容量的尾
  };
}

接下来,我们就开始进入今天的正题,模拟vector的五大步骤:

1、构造和销毁

2、迭代器相关

3、容量相关

4、元素访问

5、vector的修改操作

二、 vector的逐步实现

1、构造和销毁

构造的方法主要有以下五种:

·  默认构造

· 构造同时将前n个初始化

· 迭代器构造法

· 拷贝构造

· operator=运算符重载

    //一、vector的构造销毁
    //1、默认构造
    vector()
      :_start(nullptr)
      ,__finish(nullptr)
      ,_endOfStorage(nullptr)
    {}
 
    //2、构造同时将前n个初始化
    vector(size_t n, const T& m = T())
      :_start(nullptr)
      , __finish(nullptr)
      , _endOfStorage(nullptr)
    {
      reserve(n);     //开辟n个大小的空间,这个函数在后面
      while (n--)
      {
        push_back(m);     //尾插,也在后面讲
      }
    }
    //但是上面这个函数会有一个特殊情况出现
    //例如对于vector<int> v(5,3)
    //由于v中的参数是(int,int),所以编译器容易把它与迭代器相关的函数去配对
    //所以对于上面这个函数我们又写了一个vector(int n, const T& m = T())类型的来避免错误发生
    //这种情况下参数一定都为int型的,所以我们可以按顺序表的方式来写这个函数
    vector(int n, const T& m = T())
      :_start(new T[n])
      , __finish(nullptr)
      , _endOfStorage(nullptr)
    {
      for (int i = 0; i < n; i++)
      {
        _start[i] = m;
      }
    }
 
    //3、迭代器构造法
    //为了实现不同迭代器的传参构造,我们这里再创建一个迭代器模板
    template<class InputInterator>
    vector(InputInterator first, InputInterator last)
    {
      while (fast != last)
      {
        push_back(*first);     //尾插的时候会检查扩容,所以也可以不写reserve函数
        first++;
      }
    }
 
    //4、拷贝构造
    vector(const vector<T>& v)
      :_start(nullptr)
      ,_finish(nullptr)
      ,_endOfStorage(nullptr)
    {
      reserve(v.capacity());
      iterator it = begin();
      const_iterator vit = v.cbegin();       //这里涉及到const迭代器的内容,也是在后面讲
      while (vit != v.cend())
      {
        *it++ = *vit++;
      }
      _finish = it;
    }
 
    //5、operator=运算符重载
    vector<T>& operator=(vector<T> v)
    {
      swap(v);    //由于这里的v是对目标对象的复制,是开辟的新空间,所以我们完全可以swap直接交换而得
      return *this;
    }
 
    //析构
    ~vector()
    {
      if (_start)
      {
        delete _start;
        _start = _finish = _endOfStorage = nullptr;
      }
    }

2、迭代器相关

    // 迭代器相关(迭代器主要就是找到头尾)
    iterator begin()
    {
      return _start;
    }
 
    iterator end()
    {
      return _finish;
    }
 
    const_iterator cbegin() const
    {
      return _start;
    }
 
    const_iterator cend() const
    {
      return _finish;
    }

3、容量相关

容量相关的最重要的就是扩容,就是reserve函数,同时我们也需要注意一下resize函数,这两者各自的特点需要记清,这些前面文章有讲到,我们这里只强调一下:

resize函数即可以扩容,也可以缩容,同时还可以初始化,这个函数创造性挺大

size_t size() const
{
  return _finish - _start;
}
 
size_t capacity() const
{
  return _endOfStorage - _start;
}
 
bool empty() const
{
  return _start == _finish;
}
 
void reserve(size_t n)
{
  if (n > capacity())
  {
    size_t oldSize = size();
    // 1. 开辟新空间
    T* tmp = new T[n];
 
    // 2. 拷贝元素
    // 这里不能直接使用memcpy,原因我们将放到下面专门讲
    //if (_start)
    //  memcpy(tmp, _start, sizeof(T)*size);
 
    if (_start)
    {
      for (size_t i = 0; i < oldSize; ++i)
        tmp[i] = _start[i];
 
      // 3. 释放旧空间
      delete[] _start;
    }
 
    _start = tmp;
    _finish = _start + oldSize;
    _endOfStorage = _start + n;
  }
}
 
void resize(size_t n, const T& value = T())
{
  // 1.如果n小于当前的size,则数据个数缩小到n
  if (n <= size())
  {
    _finish = _start + n;
    return;
  }
 
  // 2.空间不够则增容
  if (n > capacity())
    reserve(n);
 
  // 3.将size扩大到n
  iterator it = _finish;
  _finish = _start + n;
  while (it != _finish)
  {
    *it = value;
    ++it;
  }
}

4、元素访问

元素访问关键就是运算符重载(operator[ ]),由于我们定义的类成员变量是以指针形式的,所以我们其实很容易实现这个重载

// 元素访问
T& operator[](size_t pos)
{
  assert(pos < size());
  return _start[pos];
}
 
const T& operator[](size_t pos)const
{
  assert(pos < size());
  return _start[pos];
}
 
T& front()
{
  return *_start;
}
 
const T& front()const
{
  return *_start;
}
 
T& back()
{
  return *(_finish - 1);
}
 
const T& back()const
{
  return *(_finish - 1);
}

5、vector的修改操作

vector的修改操作最关键的就是insert函数和erase函数,就是在任意位置插入和删除,尾插尾删可以直接调用这两个函数来实现,但这两个函数细节也挺多,具体实现细节看下面实现过程

// vector的修改操作
void push_back(const T& x)      //尾插,可以直接调用insert函数
{
  insert(end(), x);
}
 
void pop_back()         //尾删,跟尾插一样,可以调用erase函数
{
  erase(end() - 1);
}
 
void swap(vector<T>& v)      //这个交换函数在上面构造时是有用到的
{
  std::swap(_start, v._start);
  std::swap(_finish, v._finish);
  std::swap(_endOfStorage, v._endOfStorage);
}
 
iterator insert(iterator pos, const T& x)
{
  assert(pos <= _finish);
 
  // 空间不够先进行增容
  if (_finish == _endOfStorage)
  {
    //size_t size = size();
    size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
    reserve(newCapacity);
 
    // 如果发生了增容,需要重置pos
    pos = _start + size();
  }
 
  iterator end = _finish - 1;
  while (end >= pos)
  {
    *(end + 1) = *end;
    --end;
  }
 
  *pos = x;
  ++_finish;
  return pos;
}
 
// 返回删除数据的下一个数据
// 方便解决:一边遍历一边删除的迭代器失效问题
// (迭代器失效问题在vector中会发生,不知道的可以看我之前文章)
iterator erase(iterator pos)
{
  // 挪动数据进行删除
  iterator begin = pos + 1;
  while (begin != _finish) {
    *(begin - 1) = *begin;
    ++begin;
  }
 
  --_finish;
  return pos;
}

三、总结

上面的就是vector的模拟实现的全部代码段,这些还不是vector的全部内容,还有vector复制等几个细节我们还没讲,这个感兴趣的可以关注一下,将在下一篇讲解这些细小知识点

感谢各位大佬观看,创作不易,还请各位大佬点赞支持!!!

相关文章
|
4天前
|
存储 安全 编译器
【C++入门 四】学习C++内联函数 | auto关键字 | 基于范围的for循环(C++11) | 指针空值nullptr(C++11)
【C++入门 四】学习C++内联函数 | auto关键字 | 基于范围的for循环(C++11) | 指针空值nullptr(C++11)
|
4天前
|
存储 自然语言处理 编译器
【C++入门 三】学习C++缺省参数 | 函数重载 | 引用
【C++入门 三】学习C++缺省参数 | 函数重载 | 引用
|
4天前
|
小程序 C++
【C++入门 二 】学习使用C++命名空间及其展开
【C++入门 二 】学习使用C++命名空间及其展开
|
4天前
|
设计模式 算法 Java
【c++】STL之stack和queue详解
【c++】STL之stack和queue详解
8 1
|
4天前
|
人工智能 分布式计算 Java
【C++入门 一 】学习C++背景、开启C++奇妙之旅
【C++入门 一 】学习C++背景、开启C++奇妙之旅
|
4天前
|
设计模式 安全 编译器
【C++11】特殊类设计
【C++11】特殊类设计
24 10
|
9天前
|
C++
C++友元函数和友元类的使用
C++中的友元(friend)是一种机制,允许类或函数访问其他类的私有成员,以实现数据共享或特殊功能。友元分为两类:类友元和函数友元。类友元允许一个类访问另一个类的私有数据,而函数友元是非成员函数,可以直接访问类的私有成员。虽然提供了便利,但友元破坏了封装性,应谨慎使用。
40 9
|
4天前
|
存储 编译器 C语言
【C++基础 】类和对象(上)
【C++基础 】类和对象(上)
|
13天前
|
编译器 C++
【C++】string类的使用④(字符串操作String operations )
这篇博客探讨了C++ STL中`std::string`的几个关键操作,如`c_str()`和`data()`,它们分别返回指向字符串的const char*指针,前者保证以&#39;\0&#39;结尾,后者不保证。`get_allocator()`返回内存分配器,通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组,不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量,表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。
|
13天前
|
存储 C++
【C++】string类的使用③(非成员函数重载Non-member function overloads)
这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容,包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容,成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接,关系运算符(如`==`, `&lt;`等)用于比较字符串,以及`swap`非成员函数。此外,还介绍了`getline`函数,用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用,并给出了多个示例代码。