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

最新推荐文章于 2022-05-29 17:17:30 发布
最新推荐文章于 2022-05-29 17:17:30 发布
阅读量387 收藏 1
点赞数 2
分类专栏： C++ 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaomage1213888/article/details/123399208
版权

vector的模拟实现

文章目录

类的设计

用三个指针分别指向开始位置，最后一个数据的下一个位置，空间分配的最大位置，通过指针运算来确定数据大小和容量

请添加图片描述

vector类的设计要用模板来实现，实现元素的可变性，把vector的变量参数设置成_Ty，

指针可以直接进行访问操作，所以vector的迭代器就可以用指针封重命名得到。

template<class _Ty>
class vector {
public:
	typedef _Ty* iterator;
	iterator begin() {
		return _start;
	}
	iterator end() {
		return _finish;
	}
private:
	iterator _start;
	iterator _finish;
	iterator _end_of_storage;
};

vector的构造和析构

//空构造
vector()
	:_start(nullptr)
	, _finish(nullptr)
	, _end_of_storage(nullptr)
{}
//构造n个val
vector(int n, const _Ty& value = _Ty())
	:_start(nullptr)
	, _finish(nullptr)
	, _end_of_storage(nullptr)
{
        //扩容空间到n
	reserve(n);
	while (n--) {
        //数据遍历尾插
		push_back(value);
	}
}
//拷贝构造
vector(vector<_Ty>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _end_of_storage(nullptr)
{
	reserve(v.capacity());
        //数据遍历拷贝
	for (int i = 0; i < v.size(); ++i) {
		_finish[i] = v[i];
	}
        //更新size大小
	_finish = _start + v.size();
}
//用迭代器区间构造

// 如果使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
// 重新声明迭代器，迭代器区间[first,last]可以是任意容器的迭代器
template<class InputIterator>
vector(InputIterator first, InputIterator last) {
	reserve(last - first);
	while (first != last) {
		push_back(*first);
		++first;
	}
}
//赋值运算符重载
vector<_Ty>& operator=(vector<_Ty> t) {
	swap(t);
	return *this;
}
//析构vector对象
~vector() {
	if (_start) {
		delete[] _start;
		_start = nullptr;
		_finish = nullptr;
		_end_of_storage = nullptr;
	}
}

string容量操作

//容量操作
size_t size() const {
	return _finish - _start;
}
size_t capacity() const {
	return _end_of_storage - _start;
}
bool empty() const {
	return size() == 0;
}

//预留空间
void reserve(size_t n) {
    //先把以前的数据大小保存起来
	size_t oldSize = size();
	if (n > capacity()) {
		_Ty* new_start = new _Ty[n];
        //遍历拷贝以前的数据
        //不能直接用memcpy拷贝数据，memcpy是浅拷贝
		if (_start) {
			for (int i = 0; i < oldSize; ++i) {
				new_start[i] = _start[i];
			}
		}
        //这里要先释放以前申请的空间，防止内存泄漏
		delete[] _start;
        //更新指针位置
		_start = new_start;
		_finish = _start + oldSize;
		_end_of_storage = _start + n;
	}
}

void resize(size_t n, const _Ty& value = _Ty()) {
	//要设置容量小于size()
	if (n <= size()) {
		_finish = _start + n;
		return;
	}
	//要设置容量大于capacity()，扩容
	if (n > capacity()) {
		reserve(n);
	}
	size_t offset = n - size();
	while (offset--) {
		*_finish = value;
		++_finish;
	}
}

vector访问操作

//重载[]
_Ty& operator[](size_t pos) {
	return _start[pos];
}
const _Ty& operator[](size_t pos)const  {
	return _start[pos];
}

vector增删查改

//尾插
void push_back(const _Ty& val) {
	insert(end(), val);
}
//尾删
void pop_back() {
	erase((end() - 1));
}
//删除pos位置元素
iterator erase(iterator pos) {
	iterator begin = pos;
	while (begin != end()) {
		*begin = *(begin + 1);
		++begin;
	}
	--_finish;
	return pos;
}
//pos位置插入val值
iterator insert(iterator pos, const _Ty& val) {
	assert(pos >= _start && pos <= _finish);
	if (_finish == _end_of_storage) {
		size_t oldPos = pos - _start;
		reserve(capacity() == 0 ? 1 : 2 * capacity());
		//如果发生增容，pos迭代器失效，需要更新pos
		pos = _start + oldPos;
	}
	iterator end = _finish - 1;
	while (end >= pos) {
		*(end + 1) = *end;
		--end;
	}
	*pos = val;
	++_finish;
	return pos;
}
//交换两个vector
void swap(vector<_Ty>& v) {
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_end_of_storage, v._end_of_storage);
}

完整代码实现

#include<iostream>
#include<vector>
#include<assert.h>
namespace xiaomage {
	template<class _Ty>
	class vector {
	public:
		typedef _Ty* iterator;
		typedef const _Ty* const_iterator;

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

		//vector构造
		
		//无参构造
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_storage(nullptr)
		{}
		//构造n个val
		vector(int n, const _Ty& value = _Ty()) 
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			while (n--) {
				push_back(value);
			}
		}
		//拷贝构造
		vector(vector<_Ty>& v) 
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(v.capacity());
			for (int i = 0; i < v.size(); ++i) {
				_finish[i] = v[i];
			}
			_finish = _start + v.size();
		}
		//用迭代器区间构造

		// 如果使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
		// 重新声明迭代器，迭代器区间[first,last]可以是任意容器的迭代器
		template<class InputIterator>
		vector(InputIterator first, InputIterator last) {
			reserve(last - first);
			while (first != last) {
				push_back(*first);
				++first;
			}
		}
		//赋值运算符重载
		vector<_Ty>& operator=(vector<_Ty> t) {
			swap(t);
			return *this;
		}
		//析构vector对象
		~vector() {
			if (_start) {
				delete[] _start;
				_start = nullptr;
				_finish = nullptr;
				_end_of_storage = nullptr;
			}
		}
		//重载[]
		_Ty& operator[](size_t pos) {
			return _start[pos];
		}

		const _Ty& operator[](size_t pos)const  {
			return _start[pos];
		}

		//容量操作
		size_t size() const{
			return _finish - _start;
		}
		size_t capacity() const {
			return _end_of_storage - _start;
		}
		bool empty() const {
			return size() == 0;
		}
		void reserve(size_t n) {
			size_t oldSize = size();
			if (n > capacity()) {
				_Ty* new_start = new _Ty[n];
				if (_start) {
					for (int i = 0; i < oldSize; ++i) {
						new_start[i] = _start[i];
					}
				}
				delete[] _start;
				_start = new_start;
				_finish = _start + oldSize;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, const _Ty& value = _Ty()) {
			//要设置容量小于size()
			//要设置容量大于size()小于capacity()
			//要设置容量大于capacity()
			if (n <= size()) {
				_finish = _start + n;
				return;
			}
			
			if (n > capacity()) {
				reserve(n);
			}
			size_t offset = n - size();
			while (offset--) {
				*_finish = value;
				++_finish;
			}
		}
		//增删改查
		void push_back(const _Ty& val) {
			insert(end(), val);
		}
		void pop_back() {
			erase((end() - 1));
		}

		iterator erase(iterator pos) {
			iterator begin = pos;
			while (begin!=end()) {
				*begin = *(begin + 1);
				++begin;
			}
			--_finish;
			return pos;
		}

		iterator insert(iterator pos, const _Ty& val) {
			assert(pos >= _start && pos <= _finish);
			if (_finish == _end_of_storage) {
				size_t oldPos = pos - _start;
				reserve(capacity() == 0 ? 1 : 2 * capacity());
				//如果发生增容，pos迭代器失效，需要更新pos
				pos = _start + oldPos;
			}
			iterator end = _finish-1;
			while (end>=pos) {
				*(end + 1) = *end;
				--end;
			}
			*pos = val;
			++_finish;
			return pos;
		}

		void swap(vector<_Ty>& v) {
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}
xiaomage1213888
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
STL vector的内部实现原理及基本用法
qinm的专栏
02-23 4万+
本文基于STL vector源代码，但是不考虑分配器allocator，迭代器iterator，异常处理try/catch等内容，同时对_Ucopy（）、 _Umove（）、 _Ufill（）函数也不会过度分析。一、vector的定义template<class _Ty, class _Ax> class vector : public _Vector_val<_Ty
C++ vector STL实现详解
cyber的博客
11-19 2989
前言 stl库位置 vector代码分析 vector变量gdb输出总结0.前言  早前使用gdb调试特别不习惯，1）没有具备图形界面IDE（比如Visual Studio）的强大功能：边打断点边代码跟进，退出断点保存，可以随时查看当前变量数据，对stl变量显示友好。2）gdb打印输出的内容有时难以理解，比如gdb只会打印出stl相关容器、复杂的类对象，智能指针的成员数据，而不会做格式化内容输出。比
C++STL内部实现原理
xzengwei1313的博客
07-26 3162
STL包含：容器、算法、迭代器、仿函数和适配器 本文只讲容器，实现原理也是我们常见的数据结构。 1、序列式容器 vector：也叫向量，尾部可变长数组。内部通过数组实现。空间不够时会重新分配内存，然后将原来的元素拷贝到新分配的数组中。 queue：数组、单向队列。先入先出。能将任意类型的序列容器转换为队列，由deque支持。 deque：数组、双向队列。分配中央控制器map（不是map容...
C++ STL——模拟实现vector
HanMeng的博客
05-07 765
文章目录：1. vector的介绍2.STL—vector的使用2.1 vector的构造接口2.2 vector iterator 的使用2.3 vector空间增长问题2.4 vector 的增删查改交换接口3. vector 迭代器失效问题3.1 对于vector可能引起迭代器失效的操作 1. vector的介绍 点击查看—>[vector的文档介绍] （1）vector是表示可变大小数组的序列容器。 （2）就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对
c++ STL之vector的实现
Juicewyh的博客
09-24 3669
概述     vector作为STL中最常用的容器之一，他基于数组实现，是一个动态数组，其容量能自动增长，同时也提供了许多操作方法，十分高效实用。那么我们来尝试写一个自己的vector吧！（当然，自己写的肯定没有STL中的高效，就当是一次学习探索吧） 开工！ 如何实现动态数组以及如何使其容量自动增长？     这里我们用指针通过在堆空间上开辟空间来实现动态数组。设置两个变量theSize（...
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会自动分配更大的内存空间并复制现有...
STL之Vector实现原理
qq_36534818的博客
08-01 8252
Vector的基本知识         在C++中，我们使用信息隐藏技术和封装技术把数据隐藏在类内部不许外部直接操作，同时提供访问器（如get_xxx成员函数）和修改器（如set_xxx成员函数）。STL容器的设计原理如出一辙，只是它们在实现时考虑的问题更多，更加复杂而已。容器不仅把元素对象隐藏起来了，而且把元素对象的内存申请和释放操作也全部隐藏起来了（通过存储分配器），这就使程序员彻底摆脱了直
C++ STL vector的实现机制
weixin_41066529的博客
05-05 484
vector就是动态数组.它也是在堆中分配内存,元素连续存放,有保留内存,如果减少大小后，内存也不会释放.如果新值>当前大小时才会再分配内存. 它拥有一段连续的内存空间，并且起始地址不变，因此它能非常好的支持随即存取，即[]操作符，但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当该数组后的内存空间不够时，需要重新申请一块足够大的内存并进行内存的拷贝。这些都大...
STL中的Map和Vector的内部实现
u010027411的博客
04-19 2800
两个关键大小： 大小：size=_Mylast - _Myfirst； 容量：capacity=_Myend - _Myfirst； 分别对应于resize()、reserve()两个函数。 size表示vector中已有元素的个数，容量表示vector最多可存储的元素的个数；为了降低二次分配时的成本，vector实际配置的大小可能比客户需求的更大一些，以备将来扩充，这就是容量的概念。即...
C++ STL中 vector 的模拟实现
Butayarou的博客
03-20 1406
文章目录一、前言二、模拟实现的意义何在？三、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的内部实现原理及基本用法
bob的博客
08-03 6364
本文基于STL vector源代码，但是不考虑分配器allocator，迭代器iterator，异常处理try/catch等内容，同时对_Ucopy（）、 _Umove（）、 _Ufill（）函数也不会过度分析。 一、vector的定义 template<class _Ty, class _Ax> class vector : public _Vector_val<_Ty, _Ax> { // varying size array of v
C++ vector 底层实现
chengjian168的博客
08-05 2054
STL众多容器中，vector 是最常用的容器之一，其底层所采用的数据结构非常简单，就只是一段连续的线性内存空间。 通过分析 vector 容器的源代码不难发现，它就是使用 3 个迭代器（可以理解成指针）来表示的： //_Alloc 表示内存分配器，此参数几乎不需要我们关心 template <class _Ty, class _Alloc = allocator<_Ty>> class vector{ ... protected: pointer _Myfi..
自己动手实现一个C++STL中的vector
m0_47262980的博客
07-11 427
myVector and myDeque 自己动手实现了一个c++ stl中的vector容器，利用三根指针实现，简单易懂，大部分功能都实现了，还请各位批评指正。 三根指针分别为start，finish，end_of_storage，用于控制vector的容量，程序包含丰富的测试用例。 废话不多说，直接上代码。 该代码为头文件的内容 #ifndef myVector_h #define myVector_h template <typename T> class myVector { publ
C++ STL容器的底层实现
菜鸡工坊
07-20 1236
https://blog.csdn.net/qq_43313035/article/details/89600276 顺序容器： vector deque list 关联容器： set multiset map multimap vector（向量容器） 特点： 内存可2倍增长的动态数组 数据结构：线性连续空间 增加新元素时，如果超出当前容量，则容量会扩充至两倍。如果两倍还不够，则扩张至足够...
6.用c++实现stl中的vector
xiaoduan6的博客
05-29 127
#include <iostream> #include <ctime> using namespace std; template<typename T> class vector { public: vector(int size=10) { _first = new T[size]; _last = _first; _end = _first + size; } ~vector() { delete[]_first; _first
模拟C++STL中的vector的实现
最新发布
05-11
下面是一个简单的C++STL中vector的实现，仅供参考： ```c++ template class myVector{ private: T *data; // 存储空间指针 int capacity; // 当前容量 int size; // 元素个数 public: // 构造函数 myVector()...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xiaomage1213888

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

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

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

打赏作者

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

抵扣说明：

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

余额充值