vector类的模拟实现

于 2022-12-03 14:46:58 发布
阅读量186 收藏
点赞数
分类专栏： STL C++语言 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lang_965/article/details/128161558
版权

目录

一、构造和销毁

二、vector中的迭代器

三、容量操作

四、元素访问

五、修改操作

六、源代码

一、构造和销毁

//构造和销毁
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_endOfStorage(nullptr)
		{}
		vector(size_t n, const T& value = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			reserve(n);
			while (n--)
			{
				push_back(value);
			}
		}
		vector(int n, const T& value = T())
			:_start(new T[n])
			, _finish(_start + n)
			, _endOfStorage(_finish)
		{
			for (int i = 0; i < n; ++i)
			{
				_start[i] = value;
			}
		}
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		vector(const vector<T>& v)
			:_statr(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			reserve(v.capacity());
			iterator it = begin();
			const_iteraotr vit = v.cbegin();
			while (vit != v.cend())
			{
				*it++ = *vit++;
			}
			_finish = it;
		}
		vector<T>& operator=(vector<T>v)
		{
			swap(v);
			return *this;
		}
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endOfStorage = nullptr;
			}
		}

二、vector中的迭代器

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

三、容量操作

size_t size()const
		{
			return _finish - _size;
		}
		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();
				//开辟新空间
				T* tmp = new T[n];
				//拷贝元素
				if (_start)
				{
					for (size_t i = 0; i < oldSize; ++i)
					{
						tmp[i] = _start[i];
						//释放旧空间
						delete[] _start;
					}
					_start = tmp;
					_finish = _start + oldSize;
					_endOfStorage = _start + n;
				}
			}

		}
		void resize(size_t n, const T& value = T())
		{
			//如果n小于当前的size，则数据个数缩小到n
			if (n <= size())
			{
				_finish = _start + n;
				return;
			}
			//空间不够则扩容
			if (n > capacity())
			{
				reserve(n);
			}
			//将size扩大到n
			iterator it = _finish;
			_finish = _start + n;
			while (it != _finish)
			{
				*it = value;
				++it;
			}
		}

四、元素访问

T& opeartor[](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);
		}

五、修改操作

void pop_back(const T& x)
		{
			insert(end(), x);
		}
		void pop_back()
		{
			erase(end() - 1);
		}
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_ednOfStorage, 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;
		}

		// 返回删除数据的下一个数据
		// 方便解决:一边遍历一边删除的迭代器失效问题
		iterator erase(iterator pos)
		{
			// 挪动数据进行删除
			iterator begin = pos + 1;
			while (begin != _finish) {
				*(begin - 1) = *begin;
				++begin;
			}

			--_finish;
			return pos;
		}

六、源代码

#pragma once
#include<iostream>
using namespace std;
#include<assert.h>
namespace sunlang
{
	template<class T>
	class vector
	{
	public:
		//vector的迭代器是一个原生指针
		typedef T* iterator;
		typedef const T* const_iterator;
		//构造和销毁
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_endOfStorage(nullptr)
		{}
		vector(size_t n, const T& value = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			reserve(n);
			while (n--)
			{
				push_back(value);
			}
		}
		vector(int n, const T& value = T())
			:_start(new T[n])
			, _finish(_start + n)
			, _endOfStorage(_finish)
		{
			for (int i = 0; i < n; ++i)
			{
				_start[i] = value;
			}
		}
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		vector(const vector<T>& v)
			:_statr(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			reserve(v.capacity());
			iterator it = begin();
			const_iteraotr vit = v.cbegin();
			while (vit != v.cend())
			{
				*it++ = *vit++;
			}
			_finish = it;
		}
		vector<T>& operator=(vector<T>v)
		{
			swap(v);
			return *this;
		}
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endOfStorage = nullptr;
			}
		}
		//迭代器相关
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator cbegin()const
		{
			return _start;
		}
		const_iterator cend()const
		{
			return _finish;
		}
		//容量相关
		size_t size()const
		{
			return _finish - _size;
		}
		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();
				//开辟新空间
				T* tmp = new T[n];
				//拷贝元素
				if (_start)
				{
					for (size_t i = 0; i < oldSize; ++i)
					{
						tmp[i] = _start[i];
						//释放旧空间
						delete[] _start;
					}
					_start = tmp;
					_finish = _start + oldSize;
					_endOfStorage = _start + n;
				}
			}

		}
		void resize(size_t n, const T& value = T())
		{
			//如果n小于当前的size，则数据个数缩小到n
			if (n <= size())
			{
				_finish = _start + n;
				return;
			}
			//空间不够则扩容
			if (n > capacity())
			{
				reserve(n);
			}
			//将size扩大到n
			iterator it = _finish;
			_finish = _start + n;
			while (it != _finish)
			{
				*it = value;
				++it;
			}
		}
		//元素访问
		T& opeartor[](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);
		}
		//vector的修改操作
		void pop_back(const T& x)
		{
			insert(end(), x);
		}
		void pop_back()
		{
			erase(end() - 1);
		}
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_ednOfStorage, 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;
		}

		// 返回删除数据的下一个数据
		// 方便解决:一边遍历一边删除的迭代器失效问题
		iterator erase(iterator pos)
		{
			// 挪动数据进行删除
			iterator begin = pos + 1;
			while (begin != _finish) {
				*(begin - 1) = *begin;
				++begin;
			}

			--_finish;
			return pos;
		}
	private:
		iterator _start;		// 指向数据块的开始
		iterator _finish;		// 指向有效数据的尾
		iterator _endOfStorage;  // 指向存储容量的尾
	};
}

我要搞钱，我要搞钱，我要搞钱，我要爬出底层！

发烧的CPU
关注
专栏目录
vector类 代码实现
08-04
使用C++语言实现标准库容器vector类代码，虽然与标准库源码有点出入，但功能已经大部分实现。
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
Vector类实现（C++）
qq_40229767的博客
01-20 700
#pragma once #define DEFAULT_CAPACITY 10 templateclass Vector { private:int _capacity ; T*_elem; int _size;//容量默认为10，指向元素的指针，向量的规模 public: Vector(int c=DEFAULT_CAPACITY) { _elem = new T[_capacity =
实现一个简单的vector类
几度枉生_
07-15 500
vector ---- 序列容器-----可变大小数组 存储：连续存储空间来存储元素 vector是使用动态分配数组来存储它的元素。就时间而言，相对较高 因此，vector占用了更多的存储空间，并且以一种有效的方式动态增长 访问：采用下标进行访问，与数组访问一样高效 与其他动态序列容器相比，vector访问元素，在末尾添加和删除元素更加高效 大小：vector会分配一些额外的空间，防止一些可能的增长 他的大小会被容器自动处理 并不是每一次元素加入到容器时，都会重新分配大小 vector构造函数： vecto
vector类的实现
天王盖地虎！
12-19 465
template class Vector { public: enum {SPARE_CAPACITY=16}; explicit Vector(int initSize=0):theSize(initSize),theCapacity(initSize+SPARE_CAPACITY){objects=new Object[theCapacity];} Vector(const Vect
Vector实现类
再来一块红烧肉
03-24 261
  与ArrayList类似，Vector底层是用数组实现的List，相关的方法都加了同步检查，因此“线程安全,效率低”。 比如，indexOf方法就增加了synchronized同步标记。源码： public synchronized int size() { return elementCount; } public synchronized int ...
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的模拟实现
08-09
vector的模拟实现
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
[DS]实现Vector类
祥的专栏
06-23 516
原创文章，欢迎转载。转载请注明：转载自 祥的博客 原文链接：] 1.来源 2.源码 2.1.源码: QVector.h 2.2.测试 main.cpp 1.来源 本例程主要是实现vector类，来源于《数据结构与算法分析：C++描述》中。实现了题3.7和3.8中的添加索引时的边缘检测功能和添加了insert()和eraser()功能。 对于该例子中，V...
vector类接口实现
R_T_P_A_D的博客
12-03 280
namespace VECTOR { template&lt;class T&gt; class vector { public: typedef T* Iterator; typedef const T* ConstIterator; Iterator begin() { return _start; } Iterator end() { re...
vector的实现
zk_sima的专栏
03-11 2947
<br />有了前面的基础后，我们知道对于特定的容器，我们一般要有对应的iterator与之对应，因为不同的容器，对应不同的数据结构，不同的数据结构对应不同的存取方式，所以也对应了不同的iterator类型。<br />我们知道vector容器对应的iterator肯定是 std::random_access_iterator_tag 类型的，它代表这种迭代器可以随机访问。<br />所以跟前面一样我们的迭代器首先应该实现 相应类型接口：<br />public:<br /> typedef typenam
Vector 实现类
酸奶牛的博客
04-27 89
Vector 实现类
C++实现Vector类
xuuiao的专栏
06-07 1906
#ifndef _VECTOR_H_#define _VECTOR_H_#include #include #pragma warning(disable: 4715)#pragma warning(disable: 4244)template class VRAPI Vector{public: typedef _Type* pointer;  // 数据类型指针 class I
vector类的简单实现
Christal_RJ的博客
04-13 198
vector支持很多种数据类型，故要定义成模板类 0、数据成员 长度 theSize 容量 theCapacity 指针 T* array 另外还要指定容量的增长步长 int theSize; int theCapacity; T* array; #define WALK_LENGTH 64; 1、构造函数 无参数构造函数 用几个相同值初始化的构造函数 拷贝构造函数 析构函数...
vector实现
Monster的博客
07-23 103
#include<iostream> #include<vector> #include<string> using namespace std; /* 用三个指针实现顺序表, 实际上库里也是这么走的 start: 空间的首地址, 第一个元素的首地址 finish: 最后一个元素的下一个位置 end_of_storage: 空间的结束位置 用指针的偏移量计算size和capacity size = finish - start capacity
简单实现一下vector
weixin_44321570的博客
05-25 413
vector是C++STL中的内容，不过可以自己简单实现以下。 重点是，将其中的数据，使用指针来存放，这就引出了深浅拷贝的问题，必须是深拷贝。 代码中的重载 = 运算符，考虑的很周到了。 以及，取front、back、[ ] 的返回值都是引用，可以用于更改数据。 #include <bits/stdc++.h> using namespace std; class myVector { int* p; int cnt; public: myVector
vector中insert模拟实现
最新发布
10-10
在C++中，Vector是一种...这个模拟实现并不包含所有vector的功能，如reserve()预分配空间，但它展示了基本的插入操作原理。在实际使用中，你应该依赖STL提供的`std::vector`，因为它已经优化过并处理了各种边界情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

发烧的CPU

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

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

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

打赏作者

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

抵扣说明：

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

余额充值