C++【STL】之vector模拟实现

最新推荐文章于 2024-07-21 22:06:29 发布
最新推荐文章于 2024-07-21 22:06:29 发布
阅读量521 收藏 2
点赞数 4
分类专栏： C++ 文章标签： c++ STL vector 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cw412524/article/details/131236354
版权

C++ vector类模拟实现

上一篇讲解了vector的使用，这一篇接着介绍vector的模拟实现，这里依然是讲解常用接口的模拟实现，话不多说，正文开始！

文章目录：

1. 成员变量

vector的成员变量是三个指针

namespace sakura	//命名空间
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator; //迭代器
		typedef const T* const_iterator;
	private:
    	iterator _start; //指向已开辟空间起始位置
    	iterator _finish; //指向有效元素的下一个位置
    	iterator _end_of_storage; //指向已开辟空间的下一个位置
	};
}

我们使用vector存储的数据类型会是int、char等不同的类型，使用模板可以更好的实例化

2. 默认成员函数

2.1 构造和析构

构造函数

//默认构造
vector()
    :_start(nullptr)
    ,_finish(nullptr)
    ,_end_of_storage(nullptr)
{}
//带参构造
vector(size_t n, const T& val = T()) //const T&修饰匿名对象->起别名延长生命周期
    :_start(nullptr)
    , _finish(nullptr)
    , _end_of_storage(nullptr)
{
    reserve(n);
    for (size_t i = 0; i < n; ++i)
    {
        push_back(val);
    }
}
//此版本避免匹配迭代器区间构造
vector(int n, const T& val = T()) //const T&修饰匿名对象->起别名延长生命周期
    :_start(nullptr)
    , _finish(nullptr)
    , _end_of_storage(nullptr)
{
    reserve(n);
    for (int i = 0; i < n; ++i)
    {
        push_back(val);
    }
}
//迭代器区间构造 左闭右开[first, last)
template<class InputIterator>
vector(InputIterator first, InputIterator last) 
    :_start(nullptr)
    , _finish(nullptr)
    , _end_of_storage(nullptr)
{
    while (first != last)
    {
        push_back(*first);
        ++first;
    }
}

这里vector(size_t n, const T& val = T())使用了匿名对象做缺省值

  • 匿名对象的生命周期只在本行有效，但其被const修饰后生命周期会延长
  • 内置类型也能创建匿名对象，如int()、char()

*注意： 这里需要额外提供一个 vector(int n, const T& value = T()) 版本，避免使类似vector<int> v(6, 8) 构造对象会优先匹配上迭代器构造，造成 非法间接寻址错误

析构函数

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

_start 指向的是已开辟空间的首位置，可以直接对其释放，由于申请空间用的是new []，所以释放时需要对应使用delete []

2.2 拷贝和赋值

拷贝构造

拷贝构造对象前先进行扩容，避免空间浪费，这里采用逐个数据赋值拷贝的方式，因为 T 有可能是自定义类型，这样可以避免浅拷贝问题

vector(const vector<T>& v)
    :vector() //使用默认构造初始化
{
    reserve(v.capacity());	//扩容
    _start = new T[v.capacity()];
    //memcap(_start, v._start, sizeof(T) * v.size()); //浅拷贝，err
    for (size_t i = 0; i < v.size(); ++i)
    {
        _start[i] = v._start[i];
    }
    _finish = _start + v.size();
    _end_of_storage = _start + v.capacity();
}

这里不能采用memcpy来进行拷贝操作，因为memcpy是浅拷贝

vector的拷贝构造必须自己实现，默认生成的是浅拷贝

赋值重载

赋值重载的实现和拷贝构造差不多，只是不需要新对象，只需进行赋值操作即可

vector<T>& operator=(const vector<T>& v)
{
    if (this != &v)
    {
        reserve(v.capacity());	//扩容
        size_t pos = 0;
        for (size_t i = 0; i < v.size(); ++i)
        {
            *(_start + i) = *(v.begin() + i)
        }
        _finish = begin() + v.size();
    }
    return *this;
}

3. 容量操作

3.1 查看容量大小和判空

可以直接通过迭代器操作获取所需值

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

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

bool empty()
{
    return _start == _finish;
}

3.2 reserve方法

操作步骤：

  • 判断是否需要扩容
  • 拷贝数据，保存有效元素大小
  • 开辟新空间，将拷贝的数据移动至新空间，然后释放旧空间，更改指针指向
void reserve(size_t n)
{
    if (n > capacity())
    {
        size_t sz = size(); //先保存有效元素大小
        T* tmp = new T[n]; //开辟新空间
        if (_start)
        {
            for (size_t i = 0; i < sz; ++i) //深拷贝
			{
				tmp[i] = _start[i];
			}
            delete[] _start; //释放原空间
        }
        _start = tmp;
        _finish = _start + sz;
        _end_of_storage = _start + n;
    }
}

先保存有效元素大小这一步很重要！！！

因为size() = _finish - _start，所以_finish = _start + size()，再代入size()就造成了_finish = _start + _finish - _start --> _finish = _finish恒等式

3.3 resize方法

操作步骤：

  • 判断n与size()的大小
  • 如果n < size()就删除超出数据，反之就插入
void resize(size_t n, T val = T())
{
    if (n < size())
    {
        //删除数据
        _finish = _start + n;
    }
    else
    {
        if (n > capacity())
            reserve(n);
        while (_finish != _start + n)
        {
            *_finish = val;
            ++_finish;
        }
    }
}

4. 数据访问

4.1 下标访问

下标访问就是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];
}

4.2 迭代器

vector中的迭代器使用的是原生指针，如 begin() == _start、end() == _finish，这里需要提供普通版本和const版本的两种迭代器

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

iterator end()
{
    return _finish;
}

const_iterator begin() const
{
    return _start;
}

const_iterator end() const
{
    return _finish;
}

5. 数据修改

5.1 push_back方法

尾插要注意首先判断容量是否足够，然后插入数据改变_finish指向即可

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

5.2 pop_back方法

尾删需要先判断容器中是否有数据，然后直接该变_finish指向即可

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

5.3 insert方法

iterator inseret(iterator pos, const T& val)
{
    assert(pos >= _start);
    assert(pos <= _finish);
    if (_finish == _end_of_storage)
    {
        size_t len = pos - _start; //记录当前迭代器的位置（pos和_start间的距离）
        reserve(capacity() == 0 ? 4 : capacity() * 2);
        //扩容后更新pos，解决pos失效问题
        pos = _start + len;
    }
    iterator end = _finish - 1;
    while (end >= pos)
    {
        *(end + 1) = *end;
        --end;
    }
    *pos = val;
    ++_finish;
    return pos;
}

注意：

insert()的实现中，一定要先记录pos的位置，因为在扩容后迭代器pos的位置会指向已释放的旧空间，导致迭代器失效！

迭代器失效演示：

改进方法：

5.4 erase方法

iterator erase(iterator pos)
{
    assert(pos >= _start);
    assert(pos < _finish);
	//迭代器区间删除
    iterator start = pos + 1;
    while (start != _finish)
    {
        *(start - 1) = *start;
        ++start;
    }
    --_finish;
    return pos;
}

visual studio2019中的erase机制是一定会pos迭代器失效

6. 完整代码

#pragma once

#include <iostream>
#include <vector>
#include<assert.h>
#include <functional>
#include<algorithm>
#include<vector>
using namespace std;

namespace sakura
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		//默认构造
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}
		//带参构造
		vector(size_t n, const T& val = T()) //const T&修饰匿名对象->起别名延长生命周期
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			for (size_t i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}
		//此版本避免匹配迭代器区间构造
		vector(int n, const T& val = T()) //const T&修饰匿名对象->起别名延长生命周期
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}
		//迭代器区间构造 左闭右开[first, last)
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

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

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

		vector(const vector<T>& v)
			:vector() //使用默认构造初始化
		{
			reserve(v.capacity());	//扩容
			_start = new T[v.capacity()];
			//memcap(_start, v._start, sizeof(T) * v.size()); //浅拷贝，err
			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()
		{
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size(); //先保存有效元素大小
				T* tmp = new T[n]; //开辟新空间
				if (_start)
				{
					for (size_t i = 0; i < sz; ++i) //深拷贝
					{
						tmp[i] = _start[i];
					}
					delete[] _start; //释放原空间
				}
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, T val = T())
		{
			if (n < size())
			{
				//删除数据
				_finish = _start + n;
			}
			else
			{
				if (n > capacity())
					reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

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

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

		iterator inseret(iterator pos, const T& val)
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start; //记录当前迭代器的位置（pos和_start间的距离）
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				//扩容后更新pos，解决pos失效问题
				pos = _start + len;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = val;
			++_finish;
			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			//迭代器区间删除
			iterator start = pos + 1;
			while (start != _finish)
			{
				*(start - 1) = *start;
				++start;
			}
			--_finish;
			return pos;
		}

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

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

		bool empty()
		{
			return _start == _finish;
		}

		vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				reserve(v.capacity());	//扩容
				size_t pos = 0;
				for (size_t i = 0; i < v.size(); ++i)
				{
					*(_start + i) = *(v.begin() + i)
				}
				_finish = begin() + v.size();
			}
			return *this;
		}

		T& operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];
		}

		const T& operator[](size_t pos) const
		{
			assert(pos < size());
			return _start[pos];
		}
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};

	void func(const vector<int>& v)
	{
		for (size_t i = 0; i < v.size(); ++i)
		{
			cout << v[i] << " ";
		}
		cout << endl;

		vector<int>::const_iterator it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;
	}
}

C++【STL】之vector模拟实现，到这里就介绍结束了，本篇文章对你由帮助的话，期待大佬们的三连，你们的支持是我最大的动力！

文章有写的不足或是错误的地方，欢迎评论或私信指出，我会在第一时间改正！

茉莉蜜茶v
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
C++ STL之vector的使用及模拟实现
czh1592272237的博客
01-21 920
本篇文章详细讲解了STL中vector的使用及模拟实现。
C++ [STL之vector模拟实现]
ARMCSKGT的博客
05-27 5240
vector是STL容器容器之一，其底层实现类似于数据结构顺序表，相当于string来说得益于泛型模板的加持使得vector可以变为任何类型，且是可以动态扩容，堪称大号数组！在vector的实现中，有许多值得我们学习的细节，接下来将为大家一 一介绍！
C++ STL中 vector 的模拟实现
Butayarou的博客
03-20 1384
文章目录一、前言二、模拟实现的意义何在？三、vector类的模拟实现成员函数：0.迭代器相关函数begin 函数end 函数1.构造函数2.析构函数3.拷贝构造函数4.赋值重载函数5. size 函数6. capacity 函数7. swap 函数 一、前言 在C++的STL中，vector 是一个顺序容器，代表一个可动态增长的数组。因此，自己在进行模拟实现时，跟写动态顺序表类似。 vector 是一个类模板。 推荐的 C/C++ 参考文档：http://www.cplusplus.com 二、模拟实现
C++ 【vector模拟实现】
我心如火
10-06 1565
vector模拟实现；迭代器失效；
c++:模拟实现vector
海绵宝宝的欧尼~ 的博客
12-18 1260
一些说明：1）注意这里我实现的是动态顺序表。                  2）容器类其实也就是顺序表，不过它的功能更强大，这里我只是简单的模拟实现一些简单的接口。 #include #include using namespace std; template class Vector { public: Vector(); Vector(T arr[],size_t size);
c++ vector模拟实现代码
08-25
在C++标准模板库(STL)中，`vector`是一个非常关键的容器，它提供了类似于动态数组的功能。本文将深入探讨`vector`的实现原理，并通过一个简单的模拟代码来展示其核心机制。 首先，`vector`是一个序列容器，它允许在...
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
C++开源项目：模拟实现小型STL
11-27
本开源项目旨在模拟实现一个小型STL，帮助开发者更深入地理解STL的工作原理和设计思想。下面我们将详细探讨其中涉及的知识点。 1. **容器**：STL中的容器是用来存储数据的对象，如`vector`、`deque`、`list`、`set`...
C++的Vector实现.zip
08-20
本项目的目标是实现一个自定义的`Myvector`类，模拟`std::vector`的部分功能。 `std::vector`的核心特性包括： 1. 动态增长：当向vector中添加元素，且当前容量不足时，vector会自动分配更大的内存空间并复制现有...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 225
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
C++笔试强训7
最新发布
m0_74189279的博客
07-21 565
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 564
学懂C语言系列,C语言基本语法
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作
zhyjhacker的博客
07-21 726
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作。
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 287
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 127
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 1483
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
【C++】获取环境变量
Badme
07-18 8746
【C++】获取环境变量
C语言强化-1.数据结构概述
Annabelle___的博客
07-18 634
与408的关联：1. 逻辑结构和存储结构在选择题中会有涉及。2. 时间复杂度几乎是每一年大题必考内容！
Windows 点云生成二维栅格图 [附C++完整代码实现]
weixin_43896283的博客
07-17 4515
三维点云数据转换为二维栅格图
模拟C++STL中的vector的实现
05-11
下面是一个简单的C++STL中vector的实现，仅供参考： ```c++ template class myVector{ private: T *data; // 存储空间指针 int capacity; // 当前容量 int size; // 元素个数 public: // 构造函数 myVector()...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

茉莉蜜茶v

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

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

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

打赏作者

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

抵扣说明：

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

余额充值