C++ STL --＞模拟实现vector

已于 2023-12-18 20:01:19 修改
阅读量395 收藏 7
点赞数 9
分类专栏： C++ 文章标签： c++
于 2023-12-15 15:54:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FBI_BAIGOU/article/details/135019286
版权

这篇文章将模拟实现vector类的常用函数

vector类的函数接口

namespace ding
{
	template<class T>
	class vectot
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
                
		//Member functions
		vector();                                      
		vector(size_t n, const T& val);             
		template<class InputIterator>
		vector(InputIterator first, InputIterator last);   
		vector(const vector<T>& v);                       
		vector<T>& operator=(const vector<T>& v);           
		~vector();  
                
		//Iterators:
		iterator begin();
		iterator end();
		const_iterator begin()const;
		const_iterator end()const;

		//Capacity:
		size_t size()const;
		size_t capacity()const;
		void reserve(size_t n);
		void resize(size_t n, const T& val = T());
		bool empty()const;

		//Element access:
		T& operator[](size_t i);
		const T& operator[](size_t i)const;

		//Modifiers:
		void push_back(const T& x);
		void pop_back();
		iterator insert(iterator pos, const T& x);
		iterator erase(iterator pos);
		void swap(vector<T>& v);
		
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

使用三个指针来维护vector容器，让_start指向容器的头，_finish指向有效数据的尾，
_end_of_storage指向容器的尾。
image.png

Member functions

成员函数

构造函数

无参构造函数

构造一个空的容器，让三个成员变量都置为空指针即可

vector()
    :_start(nullptr)
    ,_finish(nullptr)
    ,_end_of_storage(nullptr)
{}
带参构造函数

用n个val去构造初始化vector，首先开够n个元素的空间

image.png
然后让_finish从头到尾遍历进行赋值即可
image.png

vector(size_t n, const T& val)
    :_start(nullptr)
    ,_finish(nullptr)
    ,_end_of_storage(nullptr)
{
    //开空间
    _start = new T[n];
    _finish = _start;
    _end_of_storage = _start + n;
    //赋值
    while (_finish != _end_of_storage)
    {
            *_finish = val;
            ++_finish;
    }
}
迭代器构造
//模板函数
template<class InputIterator>
vector(InputIterator first, InputIterator last)
    :_start(nullptr)
    , _finish(nullptr)
    , _end_of_storage(nullptr)
{
    //开空间
    int n = last - first;
    _start = new T[n];
    _finish = _start;
    _end_of_storage = _start + n;
    //赋值
    while (first != last)
    {
            *_finish = *first;
            ++first;
            ++_finish;
    }
}

注意:

  • 这里迭代器构造是模板函数，如果使用这个代码vector<int> v1(10, 1);实例化对象v1。
  • 本意是去调用vector(size_t n, const T& val)这个构造函数去实例化对象v1。
  • 但是编译器的匹配原则，实参10是字面量，默认是int类型，而带参构造函数是size_t类型，则会调迭代器构造函数。就会导致对int类型进行解引用操作，导致程序出错。

解决办法:

  • 重载一份带参构造函数，第一个参数设置成为int即可vector(int n, const T& val)

拷贝构造函数

这里要自己实现，编译器默认生成的拷贝构造是浅拷贝，这里需要深拷贝实现。
开一块与源容器空间大小一样的空间，然后将源容器中的数据拷贝过来即可

vector(const vector<T>& v)
        :_start(nullptr)
        , _finish(nullptr)
        , _end_of_storage(nullptr)
{
        size_t capacity = v._end_of_storage - v._start;//v的容量
        size_t size = v._finish - v._start;//v的元素个数
        _start = new T[capacity];
        memcpy(_start, v._start,sizeof(T)*size);//将源容器的数据拷贝过来。
        _finish = _start + size;
        _end_of_storage = _start + capacity;
}

注意：
如果使用memcpy进行实现，对于内置类型是没有任何问题的，但是对于自定义类型，会出错
比如下面的代码

vector<std::string> v4(3,"Hello World");
vector<std::string> v5(v4);
  • v4中存放的是4个string类型,每一个sting分别指向对应得地址空间

image.png

  • 执行vector<std::string> v5(v4),用v4构造v5.
  • v5会开辟一块和v4一样大小得空间地址
    image.png
  • memcpy拷贝得时候会把v4中得string原封不动按字节依次拷贝下来，这里就会出现问题。
  • v4和v5 虽然是不同的空间地址，但是里面的string却是同一块地址。就会导致string调用析构函数时会被析构两次，就会出错。
    image.png

解决方法:

  • 不要使用memcpy进行拷贝数据，memcpy本身就是浅拷贝。调用string类的赋值运算符重载函数进行深拷贝。
vector(const vector<T>& v)
    :_start(nullptr)
    , _finish(nullptr)
    , _end_of_storage(nullptr)
{
    size_t capacity = v._end_of_storage - v._start;//v的容量
    size_t size = v._finish - v._start;//v的元素个数
    _start = new T[capacity];
    for (size_t i = 0; i < size; i++)
    {
         _start[i] = v._start[i];
    }
    _finish = _start + size;
    _end_of_storage = _start + capacity;
}
  • 这里对于内置类型来说直接赋值，没有任何问题，对于自定义类型，会调用自己的赋值运算符重载函数进行深拷贝
  • 拷贝之后的示意图 每个对象之间指向不同地址空间，互不影响。

image.png
总结：拷贝数据对于内置类型和自定义类型的浅拷贝来说使用memcpy进行拷贝没有任何问题，但是涉及到自定义类型的深拷贝，memcpy是完成不了的。
浅拷贝：两个对象会指向同一块地址空间，一个的改变会影响到另一个
深拷贝：两个对象分别指向不同的地址空间，彼此之间互不影响

赋值运算符重载

赋值运算符重载函数的实现也要实现深拷贝，实现思路和拷贝构造一样。
唯一需要注意的就是防止自己给自己赋值和返回值问题

vector<T>& operator=(const vector<T>& v)
{
   if (this != &v)//防止自己给自己赋值
   {
           size_t capacity = v._end_of_storage - v._start;//v的容量
           size_t size = v._finish - v._start;//v的元素个数
           delete[] _start;
           _start = new T[capacity];
           for (size_t i = 0; i < size; i++)
           {
                   _start[i] = v._start[i];
           }
           _finish = _start + size;
           _end_of_storage = _start + capacity;
   }
   return *this;
}

如果自己给自己赋值，delete后，自己的数据已经没了，在进行拷贝赋值，则会出错。
返回*this是为了支持连续赋值。

析构函数

_start、_finish、_end_of_storage指向的是同一块地址空间，析构_start，让其它置空即可。

~vector()
{
        delete[] _start;
        _start = _finish = _end_of_storage = nullptr;
}

写到这回头看代码，除了析构函数其他的这是什么鬼东西，代码冗余度太高了。重复的代码太多了。
解决这个问题等后面的iterator 和capacity是实现完就可以解决了。简单来说就是把重复出现的代码封装成一个函数，函提函数复用即可。

Iterators

迭代器的模拟实现 主要实现正向迭代器。

begin && end

begin()返回容器的首地址，end()返回容器当中有效数据的下一个数据的地址
如下图所示
image.png

iterator begin()
{
    return _start;
}
iterator end()
{
    return _finish;
}
const_iterator begin()const
{
    return _start;
}
const_iterator end()const
{
    return _finish;
}

capacity

size && capacity

  • size 返回返回容器当中有效数据的个数
  • capacity 返回容器的最大容量
    image.png
size_t size()
{
    return _finish - _start;
}
size_t capacity()
{
    return _end_of_storage - _start;
}
//const版本
size_t size()const
{
    return _finish - _start;
}
size_t capacity()const
{
    return _end_of_storage - _start;
}

reserve

reserve函数的规则:

  • 当n大于对象当前的capacity时，将capacity扩大到n或大于n。
  • 当n小于对象当前的capacity时，什么也不做。即不会缩容
void reserve(size_t n)
{
    if (n > capacity())
    {
            size_t sz = size();//记录当前容器当中有效数据的个数
            T* tmp = new T[n];
            for (size_t i = 0; i < sz; i++)
            {
                    tmp[i] = _start[i];
            }
            delete[] _start;
            _start = tmp;
            _finish = _start + sz;
            _end_of_storage = _start + n;
    }
}

注意：

  • 这里也不能使用memcpy进行拷贝数据，如果是内置类型没有问题，一但是自定义类型，就会是浅拷贝，在析构时会出错。
  • 这里需要提前记录一下容器的数据个数，如果代码这样写
void reserve(size_t n)
{
    if (n > capacity())
    {
            T* tmp = new T[n];
            for (size_t i = 0; i < size(); i++)
            {
                    tmp[i] = _start[i];
            }
            delete[] _start;
            _start = tmp;
            _finish = _start +  size();
            _end_of_storage = _start + n;
    }
}
  • 12行代码去调用size函数，此时size函数中的_start已经是新空间的地址，而_finish还是旧空间的地址，在物理空间上已经不连续了，让两个指针进行相减是拿不到元素个数的。
  • 解决这个问题只能先记录元素个数，在让新空间的_start加上元素个数就是_finish的地址空间了。

resize

resize()规则：

  • 当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
  • 当n小于当前的size时，将size缩小到n
void resize(size_t n, const T& val = T())
{
    if (n < size())
    {
            _finish = _start + n;
    }
    else
    {
            if (n > capacity())
            {
                    reserve(n);
            }
            //填数据
            while (_finish != _start + n)
            {
                    *_finish = val;
                    ++_finish;
            }
    }
}

empty

判断容器是否为空，这个很简单，直接比较_start 和 _finish即可

bool empty()const
{
    return _start == _end_of_storage;
}

这里的empty函数定义成const成员函数更合理 const修饰类的成员函数实际上是修饰该成员函数隐含的this指针，表明在该成员函数中不对类的任何成员进行修改。还能防止写错写成赋值，写错编译器也能找出问题。

Element access

[]重载

T& operator[](size_t i)
{
    //检查下标合法性
    assert(i < size());
    return _start[i];
}
const T& operator[](size_t i)const
{
    assert(i < size());
    return _start[i];
}

Modifiers

push_back

尾插 首先考虑容器是否已满，若容量已满应先进行扩容操作，在插入数据。

void push_back(const T& x)
{
    //检查容量
    if (_finish == _end_of_storage)
    {
            //扩容
            size_t capacity = capacity() == 0 ? 2 : capacity() * 2;//对空容器进行判断
            reserve(capacity);
    }
    *_finish = x;
    ++_finish;
}

如果容器为空不加以判断，reserve(0)没意义，导致尾插失败

pop_back

为删时则应该考虑容器是否为空，对空容器进行检查，在删除数据
删除数据直接对_finish指针自减即可。

void pop_back()
{
    assert(!empty());
    --_finish;
}

insert

void insert(iterator pos, const T& x)
{
    if (_finish == _end_of_storage)
    {
            //扩容
            size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;//对空容器进行判断
            reserve(newcapacity);
    }
    //挪动数据插入
    iterator end = _finish -1 ;
    while (end >= pos)
    {
            *(end + 1) = *end;
            --end;
    }
    *pos = x;
    ++_finish;
}

注意：

  • insert如果按照上述的逻辑写，如果不发生扩容，没有问题，一旦在insert时发生扩容就会出问题。
  • 一旦发生扩容10行代码中的_finish已经是扩容后新空间的地址，而pos还是旧空间的地址，让end和pos去比较，没有任何意义。

image.png
解决方法：
扩容前记录pos到_start 的距离 扩容后更新pos

void insert(iterator pos, const T& x)
{
    if (_finish == _end_of_storage)
    {
            //记录pos到_start的距离
            size_t len = pos - _start;
            size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
            reserve(newcapacity);
            //扩容完更新pos
            pos = _start + len;
    }
    //挪动数据插入
    iterator end = _finish -1 ;
    while (end >= pos)
    {
            *(end + 1) = *end;
            --end;
    }
    *pos = x;
    ++_finish;
}

erase

iterator erase(iterator pos)
{
    assert(!empty());
    iterator start = pos + 1;
    while (start != _finish)
    {
            *(start - 1) = *start;
            ++start;
    }
    --_finish;
    return pos;
}

成员函数重构

//带参构造函数
vector(size_t n, const T& val)
        :_start(nullptr)
        , _finish(nullptr)
        , _end_of_storage(nullptr)
{
        reserve(n);
        for (int i = 0; i < n; ++i)
        {
                push_back(val);
        }
}
//迭代器构造函数
template<class InputIterator>
vector(InputIterator first, InputIterator last)
        :_start(nullptr)
        , _finish(nullptr)
        , _end_of_storage(nullptr)
{
        //开空间
        while (first != last)
        {
                push_back(*first);
                ++first;
        }
}
//拷贝构造函数
vector(const vector<T>& v)
        :_start(nullptr)
        , _finish(nullptr)
        , _end_of_storage(nullptr)
{

        _start = new T[v.capacity()];
        for (size_t i = 0; i < v.size(); i++)
        {
                _start[i] = v._start[i];
        }
        _finish = _start + v.size();
        _end_of_storage = _start +v.capacity();
}
//赋值运算符重载
vector<T>& operator=(const vector<T>& v)
{
    if (this != &v)//防止自己给自己赋值
    {

            delete[] _start;
            _start = new T[v.capacity()];
            for (size_t i = 0; i < v.size(); i++)
            {
                    _start[i] = v._start[i];
            }
            _finish = _start + v.size();
            _end_of_storage = _start + v.capacity();
    }
    return *this;
}
C++下等马
关注
  • 9
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
vector 模拟实现
03-20
对vector 的实现的模拟。使用《c++ primar》 中的部分代码，并进行了完善。
cpp-soa-iterator:使用 c++ struct-of-array 迭代器进行实验
06-06
C++ STL 中的vector容器和thrust device_vector容器可以很容易地用于实现结构数组数据模式。 例如，考虑一个二维点向量。 这可以用结构来实现： struct Point { double x; double y;}; 和 STL vector ： std::...
C++程序(类模板)
09-29
C++期末考试可能会考到的代码 类 类模板 模拟STL中的向量，支持用push.back()操作向Vector中加入对象，具有自动resize功能 迭代器
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 987
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 140
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 666
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
m0_62646213的博客
06-12 1102
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
9.1 图片的分割处理（c++）
最新发布
weixin_71719718的博客
06-14 639
本文的图片处理分为图片分割、图像的亚像素坐标处理。亚像素处理的原理可以看论文，该论文的详解及c++的代码实现可以看博文。下面的内容很多来自以上博文的内容，我只是对部分代码做了稍微的修改。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 288
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 281
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
【C++】 基础复习 ｜ 数据类型，输入，输出流 scanf printf
专注于人工智能的算法与应用
06-11 816
是 C 语言中两个非常重要的标准输入输出函数，它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。在这种情况下如果想控制输出，即满足一定格式输出，比如保留几位小数什么的，就要用manipulator了。需要变量的地址 ，即前面需要加一个&。函数用于从标准输入读取数据，并根据格式字符串解析这些数据。存储内存地址的变量。用户定义的复合数据类型，用于将不同类型的数据组合在一起。称做流式输入输出，
深度搜索算法3（c++）
mmz1207的博客
06-08 377
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。
手搓带头双向循环链表（C语言）
m0_62646213的博客
06-10 802
带头双向循环链表的实现与测试，优劣分析
C++ opengl 纹理映射
sss_brs的博客
06-12 102
老样子，改出来的，问GPT。
C++ Easyx案例实战：Cookie Maker工作室1.0V
快乐星空Maker的博客
06-09 721
有彩蛋！
C++:SLT容器--＞queue
坚持不懈的大白的博客
06-11 224
C++:SLT容器-->queue
C++的近邻算法详解及应用
全栈工程师Linda的博客
06-09 386
C++的近邻算法详解及应用
模拟C++STL中的vector的实现
05-11
下面是一个简单的C++STL中vector的实现，仅供参考： ```c++ template<class T> class myVector{ private: T *data; // 存储空间指针 int capacity; // 当前容量 int size; // 元素个数 public: // 构造函数 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

C++下等马

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值