STL模拟实现—vector

已于 2023-10-22 15:54:26 修改
阅读量209 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 算法 开发语言
于 2023-10-22 15:51:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56821642/article/details/133973457
版权

引言：本篇文章主要是模拟实现vector，但不同于stl中vector的成员变量都是迭代器，这个自定义的vector是一个T* 的数据变量和一个int类型的size和int类型的capacity。（有时间再写三个迭代器的版本吧！）

首先来看一下vector的结构 :

start、finish、end_of_storage都是迭代器，也就对应vector类的三个成员变量

 本篇实现的自定义vector类实现了如下功能：

  • 类模板vector的定义：模板类vector拥有构造函数、析构函数、拷贝构造函数、赋值运算符重载，以及其他一些成员函数。
  • 构造函数：默认构造函数创建一个空的向量。带有两个参数的构造函数创建一个具有指定大小和初始值的向量。
  • 析构函数：释放内存并将大小和容量重置为0。
  • 成员函数size()和capacity()：分别返回向量的大小和容量。
  • 成员函数push_back()：将元素添加到向量的末尾。如果向量已满，则自动扩容。
  • 成员函数reserve()：为向量分配指定的容量大小。
  • 重载运算符[]：通过下标访问向量中的元素。
  • 成员函数begin()和end()：返回迭代器的起始和结束位置。
  • 成员函数insert()和erase()：在指定位置插入或删除元素。
  • 成员函数find()：在指定范围内查找元素，并返回迭代器。

 下面是代码：

 my_vector.h

#pragma once
#include <iostream>
#include <assert.h>

using std::cout;  
using std::endl;

template <class T> //模板类声明
class vector{
public:
  vector(); //默认构造函数

  ~vector(); //析构函数

  vector(const vector& v); //拷贝构造函数

  vector& operator=(vector v); //赋值运算符

  typedef T* iterator; //迭代器类型定义

  typedef const T* const_iterator; //常量迭代器类型定义

  vector(size_t n,const T& val); //构造函数,用n个val初始化

  size_t size()const; //返回大小

  size_t capacity()const; //返回容量

  void push_back(const T& val); //尾部插入元素

  void reserve(size_t n); //容量预留

  T& operator[](size_t n); //下标访问运算符

  const T& operator[](size_t n)const; //常量版本下标访问运算符

  iterator begin(); //返回开始迭代器

  iterator end(); //返回结束迭代器

  const_iterator begin()const; //返回常量开始迭代器

  const_iterator end()const; //返回常量结束迭代器

  iterator insert (iterator position, const T& val); //迭代器版本插入

  iterator insert (int position,const T& val); //整数位置版本插入  

  iterator erase (iterator position); //迭代器版本删除

  iterator erase (int position); //整数位置版本删除

  iterator find (iterator _begin,iterator _end,const T& val); //查找元素

private:
  
  T* _data; //内部存储空间指针

  size_t _size; //当前大小 

  size_t _capacity; //当前容量
};

 my_vector.cpp

#include "my_vector.h"
template<class T>
vector<T>::vector()
  :_data(nullptr)
  ,_size(0)
  ,_capacity(0)
{}
template <class T>
vector<T>::~vector(){
  delete [] _data;
  _size = 0;
  _capacity = 0;
}
//构造器—开辟n个val的数组
template<class T>
vector<T>::vector(size_t n,const T& val){
  _data = new T[n];
  for(size_t i = 0; i<n;i++){
    _data[i] = val;
  }
  _size = n;
  _capacity = n;
}

template<class T>
size_t vector<T>::size()const{
  return _size;
}

template<class T>
size_t vector<T>::capacity()const{
  return _capacity;
}

template <class T>
void vector<T>::reserve(size_t n){
    if(n==0)return;
    T* tmp = new T[n];
    for(size_t i =0;i<_size;i++){//深拷贝
      tmp[i] = _data[i];
    }
    delete []_data;
    _data = tmp;
    _capacity = n;
}

template<class T>
void vector<T>::push_back(const T& val){
  if(_size == _capacity){//扩容
    _capacity = _capacity == 0?2:(_capacity*1.5);
    reserve(_capacity);
    }
    _data[_size] = val;
    _size++;
  }

template <class T>
T& vector<T>::operator[](size_t n){
    assert(n<_size);//断言n要小于size
    return _data[n];
}
template<class T>
const T& vector<T>::operator[](size_t n)const{
  assert(n<_size);
  return _data[n];
} 
template <class T>
typename vector<T>::iterator vector<T>::begin(){
  //定义时需要加上 typename 告诉编译器这是一个类型，因为这个类型是我们typedef出来的 
  return _data;
}
template <class T>
typename vector<T>::iterator vector<T>::end(){
    return _data+_size;
}
template <class T>
typename vector<T>::const_iterator vector<T>::end()const{
    return _data+_size;
}

template <class T>
typename vector<T>::const_iterator vector<T>::begin()const{
    return _data+_size;
}
template <class T>
vector<T>::vector(const vector& v){
  if(this == &v)return;//如果拷贝构造自己返回
  _data = new T[v._size];
  for(int i = 0;i<v._size;i++){
    _data[i]=v[i];
  }
  _capacity = v._size;
  _size = v._size;
}
template <class T>
vector<T>& vector<T>::operator=(vector v){
//赋值现代写法，利用传过来的值，拿临时变量v拷贝构造
//再交换他们的值，这个临时变量又会出作用域销毁
  _data = v._data;
  v._data = nullptr;
  _size = v._size;
  _capacity = v._capacity;
  return *this;
}
template <class T>
typename vector<T>::iterator vector<T>::insert (vector<T>::iterator position, const T& val){
  assert(position<=end());
  int pos = position -begin();
  if(_capacity == _size){//需要扩容
    _capacity = _capacity==0?2:(_capacity*1.5);
    reserve(_capacity);
  }
  position = begin()+pos;
  for(vector<T>::iterator it = end()-1;it>=position;it--){
     *(it+1)=*it;
  }
  *position = val;
  _size++;
  return position;
}
template <class T>
typename vector <T>::iterator vector<T>::insert(int position,const T& val){
  return insert(begin()+position,val);
}
template <class T>
typename vector<T>::iterator vector<T>::erase(vector<T>::iterator position){
  assert(position >= begin() && position < end());//迭代器不能大于或等于end()
  for(vector<T>::iterator it = position+1;it<=end();it++){
    *(it-1)=*it;
  }
  _size--;
  return position;
}
template <class T>
typename vector<T>::iterator vector<T>::erase(int position){
  return erase(begin()+position);
}
template <class T>
typename vector<T>::iterator vector<T>::find(vector<T>::iterator _begin,vector<T>::iterator _end,const T& val){
 if(_begin>=end() || _end<begin()) return nullptr;
  if(_begin<begin()) _begin=begin();//条件限制一下
  if(_end>=end()) _end = end()-1;
  for(vector<T>::iterator it = _begin;it<=_end;it++){
    if(*it == val) return it;//找到返回迭代器
  }
  return nullptr;
}

 main.cpp

#include "my_vector.cpp"
void test01(){
vector<int> v1;
  v1.push_back(1);
  v1.push_back(2);
  v1.push_back(5);
  v1.push_back(3);
  v1.push_back(100);
  cout<<v1[1]<<endl;
  for(auto& e : v1){
    cout<<e<<' ';
  }
  cout<<endl;
  cout<<v1.capacity()<<endl;
  vector<int> v2;
  v2 = v1;
  v2.insert(v2.begin()+2,1230);
  for(auto& e:v2){
    cout<<e<<' ';
  }
  cout<<endl;
  v2.erase(v2.end()-1);
  for(auto& e:v2){
    cout<<e<<' ';
  }
  cout<<endl;
  cout<<*(v2.find(v2.begin(),v2.end(),5))<<endl;
}
int main(){
  test01();
}

注意事项：

 1. mian.cpp中，需要包含的文件是my_vector.cpp，不能像一般那样包含my_vector.h

因为如果模板的声明和定义分别单独的放在.h和.cpp文件中，当要实例化一个模板时，编译器必须看到模板确切的定义，而不仅仅是它的声明。若在main()函数中包含.h文件，则编译器无法知道模板的确切定义，所以要在main()中包含.cpp文件，.cpp文件中又会包含.h文件，这样一来通过在main函数中包含.cpp文件就会将类的定义和声明都包含进来，编译器自然能找到模板的确切定义。

2. 深浅拷贝问题

 在上面的代码中，每次进行拷贝和移动时，都是经过for循环，一个个去拷到新数组中去的，并没有使用memset等函数，因为memset是以一个字节一个字节进行拷贝的，如果此时vector里面存放的是自定义类型的数据，就会出错。

3. 迭代器失效问题 

在my_vector.cpp中，insert函数如果不注意就会发生迭代器失效

如图：传进来的迭代器，如果进行扩容了，那么这个迭代器也就失效了，因为其指向的是旧空间的，而旧空间已经释放。 

所以，需要提前记录下迭代器与begin（）的距离，再到扩容后重新更新这个迭代器。

 总之：写模板类还是有点挑战的，需要多加练习！！

Hey ju
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vector 模拟实现
03-20
对vector 的实现的模拟。使用《c++ primar》 中的部分代码，并进行了完善。
MFC实现n皇后算法(附报告)
06-02
算法实验、利用MFC模拟算法中的N皇后，其中使用STL中的map、vector实现存储所有可行性。
cpp-soa-iterator:使用 c++ struct-of-array 迭代器进行实验
06-06
cpp-soa-迭代器 尝试使用 c++ struct-of-array 迭代器。 动机 数组结构数据模式通常用于 CUDA 代码以允许合并内存访问。 C++ STL 中的vector容器和thrust device_vector容器可以很容易地用于实现结构数组数据模式。 例如，考虑一个二维点向量。 这可以用结构来实现： struct Point { double x; double y; }; 和 STL vector ： std::vector< Point> p ( 10 ); p[ 0 ].x = 1.0 ; p[ 1 ].y = 1.0 ; 如果仅需要x坐标，则此数据模式不允许最有效的合并内存访问。 在实践中，感兴趣的数据结构有更多的字段（粒子物理模拟所需的数据有 10 多个字段）。 我们需要一个高效的容器来保存数组结构格式的数据，并且可以在thrust算法
STL之vector模拟实现
m0_62211222的博客
10-29 657
vector的中文意思是向量，他可以容纳很多类型的数据，因此vector也被称为容器。看到前面的解释可能你一脸蒙逼，下面我给出两种简单的理解。可以把vector理解为是一个可以动态增长的数组，一个数组可以存储多个相同类型的数据。也可以理解成是一个顺序表，里面可以存储不同类型的数据其实这两种说法本质都是一样的，因为顺序表就是用数组实现的。vector是c++的一个类，他像前面我介绍过的string类（没看过的同学看这里：）一样，有public函数，也有private成员。
【C++】STL 模拟实现之 vector
在平淡的日子里寻找存在的价值
12-01 2070
STL 容器 -- vector 的使用细节及其模拟实现。
STL模拟实现vector
IT_iverson的博客
10-31 473
首先给出所需要实现的函数接口和类的封装 template class Vector { public: Vector();//无参构造函数 Vector(const T* array, size_t size);//有参数构造函数 Vector(const Vector & v);//拷贝构造函数 Vector& operator=(const Vector& s);//赋值运算符重载
STL中vector的模拟实现
fengjunziya的博客
04-30 225
简介:STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。网上有句话说：“不懂STL，不要说你会C++”。STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构，以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。而我们，则应该学会如何使用它，理解它，再到实现它。
C++ STL --- vector类模拟实现
weixin_57761086的博客
08-29 1174
C++STL之vector的模拟实现，模拟实现了构造模块、迭代器模块、容量模块、元素访问模块、修改模块。同时讲解了为什么不能用memset和memecpy函数。使用大量代码举例子。
stl——模拟实现vector
smx_dd的博客
01-13 386
对于vector相信大家并不陌生，这里介绍一些重要的vector的接口和用法。 1. 构造函数 vector(); 无参构造 vector(size_type n, const value_type& val = value_type()); 构造并初始化n个val vector (InputIterator first, InputIterator last); 利用迭代器进行构造。 ...
STL之Vector的模拟实现
weixin_53831496的博客
09-30 237
STL之vector的模拟实现vector核心接口的模拟实现 vector核心接口的模拟实现 #include<iostream> using namespace std; namespace vr { template<class T> class vector { public: typedef T* iterator; vector() :_start(nullptr) ,_finish(nullptr) ,_endofstorage(null
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
【C++】模拟实现STL容器：vector
学了就忘是正常现象
11-24 1246
vector使用时需注意迭代器失效问题。解决方法：接收insert或erase返回值，更新当前迭代器 vector模拟实现需注意reserve中的深拷贝问题。
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
最新发布
Ddddddd_158的博客
06-04 320
C++ | Leetcode C++题解之第129题求根节点到叶节点数字之和
C语言——指针
weixin_45725380的博客
05-31 795
存储类型 数据类型 *指针变量名；例如：int *p;//定义了一个整数型指针变量pint a=5;int *p=&a;char b='v';char *q=&b;访问指针所指的空间里的内容时，需要用取内容运算符*来获取此时，变量p存放的就是a的地址，变量q存放的就是b的地址；符号*可以访问地址指向的空间里面的内容。指针与变量之间的关系如下：int i=3;本质还是指针，指向的是数组。（又称为行指针）所谓指针数组就是由若干个具有相同类型的指针变量组成的集合。
C++候捷stl-视频笔记2
Mhypnos的博客
05-31 815
候捷stl标准库学习笔记
CF Round 368 (Div. 2) C. Pythagorean Triples【数学 构造】
2301_80089588的博客
05-30 448
数学 构造
c++实战知识点
qq_24867003的博客
06-03 1043
如果一个函数既可以用全局变量也可以用静态局部变量满足该函数要求，优先考虑静态局部变量，因为更安全。- 假如我们需要的参数越来越多，那么普通函数所需要的参数也就会越来越多，我们的框架(算法findif)也需要一同修改，这个不符合代码规范。如果函数的实参不是左值或与const引用形参的类型不匹配，那么c++将创建正确类型的匿名变量，将实参的值传递给匿名变量，让形参来引用该变量。重载的operator new 和 operator delete函数都是静态函数，因此无法使用类的普通成员变量。
STL使用小记
qq_38690917的博客
05-31 296
增大或缩小容器实际存储的元素的数量resize只会改变实际存储的元素的数量，并不会改变容器的最大容量，即容器的capacity1、如果resize指定的值小于当前容器的实际存储的元素的数量，则多出来的元素都会被删除（2、如果大于当前容器的实际存储的元素数量，则会添加新的元素进行补充，按照指定的值或者容器进行值初始化。
模拟C++STL中的vector的实现
05-11
下面是一个简单的C++STL中vector的实现，仅供参考： ```c++ template<class T> class myVector{ private: T *data; // 存储空间指针 int capacity; // 当前容量 int size; // 元素个数 public: // 构造函数 myVector(){ data = new T[1]; // 初始容量为1 capacity = 1; size = 0; } // 析构函数 ~myVector(){ delete[] data; } // 返回元素个数 int getSize(){ return size; } // 返回容量 int getCapacity(){ return capacity; } // 添加元素 void push_back(T element){ if(size == capacity){ // 容量不足，扩容 T *newData = new T[capacity * 2]; for(int i=0; i<size; i++){ newData[i] = data[i]; } delete[] data; data = newData; capacity *= 2; } data[size++] = element; } // 删除最后一个元素 void pop_back(){ if(size > 0){ size--; } } // 访问元素 T& operator[](int index){ return data[index]; } }; ``` 这个实现中，我们使用了动态内存分配来实现vector的扩容和缩容，同时提供了getSize、getCapacity、push_back、pop_back、operator[]等常用操作。需要注意的是，这个实现并没有考虑线程安全等问题，实际上STL中的vector是支持多线程的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值