vector的模拟实现

最新推荐文章于 2024-11-02 20:20:37 发布
最新推荐文章于 2024-11-02 20:20:37 发布
阅读量161 收藏
点赞数
分类专栏： c++ 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZHENGZJM/article/details/133496848
版权

完整代码

  • 这是一个简单的C++实现的vector类模板。vector是一种动态数组，可以根据需要自动扩容和缩容，提供了常用的操作函数如插入、删除、访问等。

  • 该vector类模板包含以下成员函数：

  1. begin()和end()：返回迭代器，用于指向vector的起始和结束位置。

  2. cbegin()和cend()：返回常量迭代器，用于指向vector的起始和结束位置。

  3. capacity()：返回vector的容量，即分配的内存空间大小。

  4. size()：返回vector中元素的个数。

  5. resize()：调整vector的大小，如果n小于当前容量，则直接修改size()的值；如果n大于当前容量，则先通过reserve()函数进行内存的重新分配，再插入新的元素。

  6. swap()：交换两个vector对象的内容。

  7. reserve()：申请至少能容纳n个元素的内存空间，如果n大于当前容量，则重新分配内存；否则不进行操作。

  8. pop_back()：删除vector的最后一个元素。

  9. push_back()：在vector的末尾添加一个元素。

  10. insert()：在指定位置插入一个元素。

  11. erase()：删除指定位置的元素。

  12. 此外，还包括构造函数、拷贝构造函数、赋值运算符重载和析构函数。

#pragma once
#include<assert.h>
namespace hqj
{
 template<class T>
 class vector
 {
 public:
  typedef T* iterator;
  typedef const T* const_iterator;
  //迭代器部分
  iterator begin()
  {
   return _start;
  }
  iterator end()
  {
   return _finish;
  }

  const_iterator cbegin()const
  {
   return _start;
  }

  const_iterator cend()const
  {
   return _finish;
  }

  size_t capacity()const
  {
   return _endOfStorage - _start;
  }
  size_t size()const
  {
   return _finish - _start;
  }
  void resize(size_t n, const T& val = T())
  {
   if (n < capacity())
   {
    _finish = _start+n ;
   }
   else
   {
    reserve(n);
    for (int i = 0; i < n; i++)
    {
     push_back(val);
    }
   }
  }
  //交换函数
  void swap(vector<T>& v)
  {
   std::swap(_start, v._start);
   std::swap(_finish, v._finish);
   std::swap(_endOfStorage, v._endOfStorage);
  }
  //申请内存
  void reserve(size_t n)//返回类型是引用
  {
   if (n > capacity())
   {
    T* tmp = new T[n];
    int sz = size();

    if (_start != nullptr)
    {
     for (int i = 0; i < size(); i++)
     {
      tmp[i] = _start[i];
     }
    }
    delete[] _start;
    _start = tmp;
    _endOfStorage = _start + n;
    _finish = _start + sz;
   }
  }
  //尾删

  void pop_back()
  {
   assert(size() >= 0);
   _finish--;
  }
  //尾插
  void push_back(const T& x)
  {
   if (_finish == _endOfStorage)
   {
    reserve(capacity() == 0 ? 4 : 2 * capacity());
   }
   *_finish = x;
   _finish++;
  }
  //构造函数
  template<class InputIterator>

  vector(InputIterator first, InputIterator last)
  {
   while (first != last)
   {
    push_back(*(InputIterator));
    first++;
   }
  }

  vector(const vector<T>& v)
   :_start(nullptr)
   , _finish(nullptr)
   , _endOfStorage(nullptr)
  {
   reserve(v.size());
   for (auto i = v.cbegin();i!=v.cend();i++)
   {
    push_back(*i);
   }
  }

  vector<T>& operator= (vector<T> v)
  {
   vector<int> tmp(v);
   swap(tmp);
  }

  vector()
   : _start(nullptr)
   , _finish(nullptr)
   , _endOfStorage(nullptr)
  {}

  vector(int n, const T& val = T())
  {
   for (int i = 0; i < n; i++)
   {
    push_back(val);
   }
  }
  //析构函数
  ~vector()
  {
   delete[] _start;
   _start = nullptr;
   _finish = nullptr;
   _endOfStorage = nullptr;
  }
  //[]运算符重载
  T& operator[](size_t pos)
  {
   return _start[pos];
  }
  const T& operator[](size_t pos)const
  {
   return _start[pos];
  }
  //随机插入，随机删除
  iterator insert(iterator pos, const T& x)
  {
   assert(pos >= _start);
   assert(pos <= _finish);

   if (_finish == _endOfStorage)
   {
    int sz = pos - _start;//记录pos与_start的相对位置
    reserve(capacity() == 0 ? 4 : 2 * capacity());//注意迭代器失效
    pos = _start + sz;//重置迭代器
   }

   iterator en = _finish-1;
   while (en >= pos)
   {
    *(en+1) = *(en);
    en--;
   }

   *pos = x;
   _finish++;
   return pos;
  }

  iterator erase(iterator pos)
  {
   assert(pos >= _start);
   assert(pos <= _finish);

   iterator a = pos+1;
   while (a != _finish)
   {
    *(a-1) = *a;
    a++;
   }

   _finish--;
   return pos;
  }
 private:
  iterator _start;
  iterator _finish;
  iterator _endOfStorage;
 };

私有成员

  • _start 是指向存储区域的起始位置的迭代器，表示第一个元素的位置。

  • _finish 是指向实际存储数据区域的最后一个元素之后的空闲位置的迭代器，表示当前已经存储的元素数量。

  • _endOfStorage 是指向分配的内存空间的最后一个位置之后的位置的迭代器，表示当前 vector 可以存储的最大元素数量。如果 _finish 等于 _endOfStorage，那么 vector 已达到最大容量，此时需要扩容才能继续添加元素。

private:
  iterator _start;
  iterator _finish;
  iterator _endOfStorage;

迭代器部分

  • 在该代码中，通过使用typedef关键字将T和const T定义为iterator和const_iterator类型，分别表示可修改和只读的迭代器。

  • 然后，定义了以下成员函数来获取迭代器：

  1. begin()：返回一个指向vector起始位置的迭代器。

  2. end()：返回一个指向vector结束位置的迭代器，即最后一个元素的下一个位置。

  3. cbegin()：返回一个指向vector起始位置的常量迭代器，不允许修改元素。

  4. cend()：返回一个指向vector结束位置的常量迭代器，不允许修改元素。 通过使用迭代器，可以方便地遍历vector容器中的元素

typedef T* iterator;
  typedef const T* const_iterator;
  //迭代器部分
  iterator begin()
  {
   return _start;
  }
  iterator end()
  {
   return _finish;
  }

  const_iterator cbegin()const
  {
   return _start;
  }

  const_iterator cend()const
  {
   return _finish;
  }

capacity函数

  • 在实现中，使用指针之间的减法运算符来计算 _endOfStorage - _start 的值。其中 _endOfStorage 表示已分配内存空间的尾部位置， _start 表示 vector 的起始位置。

size_t capacity()const
  {
   return _endOfStorage - _start;
  }
  

size函数

  • 在实现中，使用指针之间的减法运算符来计算偏移量，从而得到 _finish - _start 的值。其中 _finish 表示 vector 的结束位置， _start 表示 vector 的起始位置。

size_t size()const
  {
   return _finish - _start;
  }

resize函数

  • 在函数实现中，首先判断 n 是否小于当前的容量 capacity()。如果是，则直接将结束位置 _finish 设置为 _start + n，即截断 vector，不需进行内存重新分配。

  • 如果 n 大于或等于当前的容量，意味着需要重新分配内存空间。此时调用 reserve(n) 函数来扩展 vector 的容量至至少 n，确保有足够的空间容纳新的元素。然后使用循环将元素 val 依次添加到 vector 中，使用 push_back() 函数将元素添加至末尾。这样就实现了重新分配内存并初始化新元素的功能。

void resize(size_t n, const T& val = T())
  {
   if (n < capacity())
   {
    _finish = _start+n ;
   }
   else
   {
    reserve(n);
    for (int i = 0; i < n; i++)
    {
     push_back(val);
    }
   }
  }

reserve函数

  • 在函数实现中，首先判断 n 是否大于当前的容量 capacity()。如果是，则需要重新分配内存空间。

  • 首先创建一个临时指针 tmp，调用 new 运算符申请一个大小为 n 的新数组。然后通过循环将原始 vector 中的元素逐个复制到新的数组中。

  • 接下来释放原始内存空间，使用 delete[] 运算符删除原始指针 _start 所指向的数组。然后将新的数组指针 tmp 赋值给 _start，以更新 vector 的起始位置。

  • 同时，更新 vector 的结束位置 _endOfStorage 为 _start + n，表示分配的内存空间的末尾位置。将 vector 的实际使用大小 _finish 更新为之前的大小 sz。

//申请内存
  void reserve(size_t n)//返回类型是引用
  {
   if (n > capacity())
   {
    T* tmp = new T[n];
    int sz = size();

    if (_start != nullptr)
    {
     for (int i = 0; i < size(); i++)
     {
      tmp[i] = _start[i];
     }
    }
    delete[] _start;
    _start = tmp;
    _endOfStorage = _start + n;
    _finish = _start + sz;
   }
  }

pop_back函数

  • 在函数实现中，首先利用 assert() 函数对 vector 的大小进行检查，确保 vector 不为空。如果 vector 为空，则会触发断言错误，程序终止运行。

  • 然后将 vector 的 _finish 指针向前移动一位，指向新的最后一个元素。由于 _finish 是指向最后一个元素的下一个位置，因此该操作实际上是将最后一个元素“弹出”了 vector。

//尾删

  void pop_back()
  {
   assert(size() >= 0);
   _finish--;
  }

push_back函数

  • 在函数实现中，首先判断 _finish 是否达到 vector 可用空间的末尾 _endOfStorage。如果是，则表示当前的内存空间已经完全使用，需要进行内存重新分配。

  • 在重新分配内存空间时，调用 reserve() 函数，将 vector 的容量扩展为原来的两倍（或4，如果当前容量为0）。

  • 然后，将新元素 x 赋值给 _finish 所指向的位置，即插入到 vector 的末尾。最后，将 _finish 指针向后移动一位，表示 vector 的大小增加了1。

void push_back(const T& x)
  {
   if (_finish == _endOfStorage)
   {
    reserve(capacity() == 0 ? 4 : 2 * capacity());
   }
   *_finish = x;
   _finish++;
  }

构造函数

  • vector(InputIterator first, InputIterator last) 构造函数使用迭代器范围 [first, last) 内的元素来初始化 vector。通过循环遍历迭代器范围内的每个元素，并调用 push_back() 函数将其添加到 vector 中。

  • vector(const vector& v)构造函数使用另一个 vector 对象 v 来初始化新创建的 vector 对象。首先通过 reserve() 函数为新 vector 分配与 v 相同大小的内存空间。然后通过循环遍历 v 中的每个元素，并调用 push_back() 函数将其添加到新 vector 中。

  • vector() 默认构造函数创建一个空的 vector 对象，没有分配任何内存空间。所有指针成员 _start、_finish 和 _endOfStorage 都被设置为 nullptr。

  • vector(int n, const T& val = T()) 构造函数创建一个包含 n 个元素的 vector 对象，并使用参数 val 的值进行初始化。通过循环调用 push_back() 函数 n 次，将 val 添加到 vector 中。

//构造函数
  template<class InputIterator>

  vector(InputIterator first, InputIterator last)
  {
   while (first != last)
   {
    push_back(*(InputIterator));
    first++;
   }
  }

  vector(const vector<T>& v)
   :_start(nullptr)
   , _finish(nullptr)
   , _endOfStorage(nullptr)
  {
   reserve(v.size());
   for (auto i = v.cbegin();i!=v.cend();i++)
   {
    push_back(*i);
   }
  }
vector()
   : _start(nullptr)
   , _finish(nullptr)
   , _endOfStorage(nullptr)
  {}

  vector(int n, const T& val = T())
  {
   for (int i = 0; i < n; i++)
   {
    push_back(val);
   }
  }

swap函数

  • 函数使用 std::swap() 函数来交换 _start、_finish 和 _endOfStorage 指针成员的值。通过调用 std::swap() 函数，将当前 vector 对象的指针成员与参数 v 的对应指针成员进行交换，实现两个 vector 对象之间的内容交换。

  //交换函数
  void swap(vector<T>& v)
  {
   std::swap(_start, v._start);
   std::swap(_finish, v._finish);
   std::swap(_endOfStorage, v._endOfStorage);
  }                                

=运算符重载

  • 函数创建了一个临时的 vector 对象 tmp，并将参数 v 复制到该对象中。然后通过调用成员函数 swap() 将当前对象和临时对象的内容进行交换，从而实现将当前 vector 对象赋值为参数 v 的操作。

  vector<T>& operator= (vector<T> v)
  {
   vector<int> tmp(v);
   swap(tmp);
  }

析构函数

  • 析构函数首先使用 delete[] 关键字释放 _start 指针指向的动态分配的数组内存空间。然后将 _start、_finish 和 _endOfStorage 的值设置为 nullptr，以避免悬挂指针的问题。

  //析构函数
  ~vector()
  {
   delete[] _start;
   _start = nullptr;
   _finish = nullptr;
   _endOfStorage = nullptr;
  }

[]运算符重载

  • T& operator[](size_t pos) 是非常规则的重载函数，用于通过下标 pos 访问 vector 中的元素，并返回对应位置的引用。在函数体内部，它直接返回 _start[pos] 的引用，从而允许调用者对该元素进行读写操作。

  • const T& operator[](size_t pos)const 是常规则的重载函数，用于在常量对象上进行下标访问。它与第一个版本的区别在于，在函数声明中加入了 const 限定符，表明该函数不会修改 vector 对象的内容。在函数体内部，它同样返回 _start[pos] 的引用，但由于函数是 const 成员函数，所以返回的引用是常量引用，只能用于读取元素的值，不能进行写操作。

  //[]运算符重载
  T& operator[](size_t pos)
  {
   return _start[pos];
  }
  const T& operator[](size_t pos)const
  {
   return _start[pos];
  }

insert函数

  • 首先，函数使用 assert() 断言来确保插入位置 pos 在有效范围内，即在 _start 和 _finish 之间（包括 _start 和 _finish）。

  • 然后，函数检查当前 vector 是否已经满了，即 _finish 是否等于 _endOfStorage。如果是满的，则需要进行扩容操作。函数通过调用 reserve() 来扩容，扩容大小为当前容量的两倍。值得注意的是，由于扩容操作可能导致原来的迭代器失效，所以在扩容之前需要记录插入位置 pos 相对于 _start 的偏移量 sz，然后在扩容后重新计算插入位置 pos。

  • 接下来，函数利用迭代器将从 pos 到 _finish-1 的所有元素向后移动一个位置。具体而言，迭代器 en 初始化为 _finish-1，然后循环将 en 指向的元素复制到 en+1 指向的位置，直到 en 等于 pos。

  • 最后，将元素 x 赋值给 pos 指向的位置，增加 _finish 的值，并返回指向插入位置的迭代器 pos。

  //随机插入
  iterator insert(iterator pos, const T& x)
  {
   assert(pos >= _start);
   assert(pos <= _finish);

   if (_finish == _endOfStorage)
   {
    int sz = pos - _start;//记录pos与_start的相对位置
    reserve(capacity() == 0 ? 4 : 2 * capacity());//注意迭代器失效
    pos = _start + sz;//重置迭代器
   }

   iterator en = _finish-1;
   while (en >= pos)
   {
    *(en+1) = *(en);
    en--;
   }

   *pos = x;
   _finish++;
   return pos;
  }

erase函数

  • 首先，函数使用 assert() 断言来确保删除位置 pos 在有效范围内，即在 _start 和 _finish 之间（包括 _start 和 _finish）。

  • 然后，函数利用迭代器将从 pos+1 到 _finish-1 的所有元素向前移动一个位置。具体而言，迭代器 a 初始化为 pos+1，然后循环将 a 指向的元素复制到 a-1 指向的位置，直到 a 等于 _finish。

  • 最后，将 _finish 减一，并返回指向删除位置的迭代器 pos。需要注意的是，虽然 pos 已经失效了，但是这里返回的仍然是指向原来的位置的迭代器，因为要保证与 STL 标准库的接口兼容。

  iterator erase(iterator pos)
  {
   assert(pos >= _start);
   assert(pos <= _finish);

   iterator a = pos+1;
   while (a != _finish)
   {
    *(a-1) = *a;
    a++;
   }

   _finish--;
   return pos;
  }
正追军梦
关注
专栏目录
vector模拟实现
.
06-12 3009
vector的模拟实现
【C++】vector模拟实现
VHhhbb的博客
07-15 1070
【C++】vector模拟实现
C++ vector模拟实现
Wzs040810的博客
01-10 3717
C++ STL vector模拟实现
Vector模拟实现
2301_77272486的博客
04-27 930
模拟实现Vector容器，深入了解Vector的底层运行原理
[C++]vector模拟实现
weixin_52345097的博客
03-05 1440
C++vector模拟实现
C++ [STL之vector模拟实现]
ARMCSKGT的博客
05-27 5315
vector是STL容器容器之一，其底层实现类似于数据结构顺序表，相当于string来说得益于泛型模板的加持使得vector可以变为任何类型，且是可以动态扩容，堪称大号数组！在vector的实现中，有许多值得我们学习的细节，接下来将为大家一 一介绍！
【C++初阶】vector模拟实现
weixin_74967884的博客
09-19 1895
本章节主要介绍了vector的模拟实现，从分模块介绍，再到最后的整合。
【C++】—— vector模拟实现
LH__1314的博客
10-04 1718
编译器在编译时，认为T已经实例化成了int，对于两个int类型，编译器就会选择更为匹配的模版。而不只是简单的浅拷贝了。​ vector成员变量，和顺序表的成员变量有所不同，不再是指针、size和capacity了，而是迭代器 start、finish和end_of_storage。​ 使用迭代器区间进行初始化，这里不一定是vector的迭代器，所以写成模板。​ 赋值运算符重载，这个编译器自动生成的是浅拷贝，我们需要写一个深拷贝的。​ 这里，扩容之后还用一个迭代器失效问题，需要重新给pos赋值。
C++ STL vector 模拟实现
qq_63943454的博客
08-10 1359
我们之前学习了，vector的使用，Vector在功能上就是我们数据结构阶段实现的顺序表基本一致，但是Vector在成员框架上与顺序表有所不同，且Vector使用类和对象封装支持模板泛型。
C++入门之vector的模拟实现
cls的博客
03-26 1211
vector源代码的大致框架,vector本质就是一个模板类 vector的成员变量不再是我们熟悉的size，capacity，而是变成了功能一致的三个指针 namespace pxl { template<class T> class vector { public: typedef T* iterator; private: iterator _start; iterator _finish; iterator _endofstora.
c++ vector模拟实现代码
08-25
下面是一个简化的`vector`模拟实现： ```cpp template class vector { public: typedef T* iterator; // 构造函数 vector() : start(nullptr), finish(nullptr), end_of_storage(nullptr) {} vector(size_t n,...
vector 模拟实现
03-20
在本模拟实现中，我们将探讨如何根据《C++ Primer》一书中的指导，创建一个基本的`vector`类，关注其核心功能，如内存管理、动态增长和STL（标准模板库）接口的兼容性。以下是对这个模拟实现的一些关键知识点的详细...
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 199
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 877
书生浦语大模型实战营第四期：Linux前置基础
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2233
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 42
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1157
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C语言之长整型有符号数与短整型有符号数转换
qq_40939768的博客
10-29 711
最近考证的新星，问了一个问题：int a = 1234565789;为什么在输出%hd时的值为-1379？其实这个很简单，只不过对于可能初入“编程坑”以及经验不是很丰富的朋友来说，感觉知道这么个道理，但就是解释不上来，无法做出实际的推论。作者想说的是，这个知识点亦涉及多方面，比较广泛，所以就以咱们未来的新星所提的问题进行分析。
C++ -- 模板进阶
最新发布
zy1215058242的博客
11-02 540
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值