【C++】vector的模拟实现

最新推荐文章于 2024-01-10 20:52:33 发布
最新推荐文章于 2024-01-10 20:52:33 发布
阅读量5k 收藏 4
点赞数 3
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68609336/article/details/128626838
版权

一、vector的迭代器

迭代器（iterator）是一个比较抽象的概念，其在STL中扮演着十分重要的角色。迭代器可以理解为一种行为类似指针的对象（可以是指针也可以不是指针），而指针的各种行为中最常见最重要的操作就是*和->，因此迭代器最重要的编程工作就是operator*和operator->。

我们知道vector使用的是连续线性的空间，所以无论其元素类型是什么，普通指针都可以作为vector的迭代器来满足所有需求，因为vector的迭代器所需的操作，（如operator*、operator->、operator++、operator--等），普通指针本来就具备。所以vector的迭代器就是普通指针

template<class T>
class vector
{
public:
	// vector的迭代器是一个普通指针
	typedef T* iterator;
	typedef const T* const_iterator;

由上述我们可以知道，如果用户写出这样的代码：

vector<int>:: ivit;
vector<Date>:: dvit;

ivit和dvit和类型分别是int*和Date*

二、vector的数据结构

vector采用的数据结构十分简单：线性连续空间。它用两个迭代器_start和_finish分别指向连续空间的已被使用范围的开始和结束，并以迭代器_endOfStorage指向整块连续空间（容量）的尾端。

为了降低扩容成本，vector实际空间大小可能比用户需求量更大一些，换句话说，一个vector的容量永远 >= 其大小。

在这里插入图片描述

增加新元素时，如果超过当前容量，则容量会扩充至两倍。至于为什么是两倍，这并不是硬性规定，只是两倍比较合适，仅此而已。

注意，上图扩容时是直接在原空间之后新增空间，实际并没有这么简单。
扩容必须经历『重新配置空间、移动元素、释放原空间』等过程，工程浩大。

使用_start、 _finish、_endOfStorage三个迭代器便可以轻易的实现获取首尾、大小、容量、容器判空等功能。

template <class T>
class vector {
	//……
public:
	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;//最后一个元素的下一个
	}
	//重载const版本，以适应const对象调用begin和end
	iterator begin() const
	{
		return _start;
	}

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

	const_iterator cend() const
	{
		return _finish;
	}

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

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

	bool empty() const
	{
		return _finish == _start;
	}
	void clear()
	{
		_finish = _start;
	}
	T& operator[](size_t pos)
	{
		assert(pos < size());//断言检查非法访问
		return *(_start + pos);
	}

	const T& operator[](size_t pos) const
	{
		assert(pos < size());
		//return *(_start + pos);
		return _start[pos];
	}
	//……
private:

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

三、vector的构造和析构

1. 构造

  1. 无参构造
vector()
	:_start(nullptr)
	, _finish(nullptr)
	, _endOfStorage(nullptr)
{
}
  1. n个value构造
    注意这里的n是int类型而不是size_t，假如我们这样构造：vector<int> v(3, 8)，会调用区间构造而发生错误
vector(int n, const T& value = T())
{
	reserve(n);//扩容
	for (int i = 0; i < n; ++i)
	{
		_start[i] = value;
	}
}
  1. 迭代器区间构造
template<class InputIterator>
vector(InputIterator first, InputIterator last)
	:_start(nullptr)
	, _finish(nullptr)
	, _endOfStorage(nullptr)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

2. 拷贝构造和赋值运算符重载

vector实现swap与string实现swap的原因相同：如果用户直接使用库中swap(v1, v2)将会发生1次拷贝构造，2次赋值，3次深拷贝代价高，而使用v1.swap(v2)仅仅交换成员变量，代价小。

库中swap的实现：
在这里插入图片描述

  • 拷贝构造
void swap(vector<T>& v)
{
	//交换成员
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endOfStorage, v._endOfStorage);
}
//使用初始化列表初始化是为了
//避免交换成员后tmp的成员变量为随机值，析构时出错
vector(const vector<T>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _endOfStorage(nullptr)
{
	//如果使用begin和end需要重载出const版本
	vector<T> tmp(v.cbegin(), v.cend());复用迭代器区间构造
	
	swap(tmp);
}
  • 赋值运算符重载
vector<T>& operator= (vector<T> v)//注意不要传引用
{
	swap(v);
	return *this;
}

3. 析构

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

四、vector的元素操作

1. push_back

当我们 push_back插入新元素时，函数首先检查是否还有备用空间，如果有就直接在_finish位置构造元素，并调整_finish；如果没有就扩容。

void push_back(const T& x)
{
	//容量满则扩容两倍
	if (_finish == _endOfStorage)
	{
		//注意首次扩容，容量初始化为4
		size_t newCapacity = _endOfStorage == 0 ? 4 : 2 * capacity();
		reserve(newCapacity);
	}
	*_finish = x;
	_finish++;
}

2. pop_back

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

3. insert

实现insert应注意迭代器失效问题，即扩容引起的野指针问题

// 在pos位置前面插入
iterator insert(iterator pos, const T& val)
{
	assert(pos >= _start);
	assert(pos < _finish);
	//1. 检查容量
	if (_finish == _endOfStorage)
	{
		size_t len = pos - _start;
		size_t newCapacity = _endOfStorage == 0 ? 4 : 2 * capacity();
		reserve(newCapacity);//扩容
		//扩容会导致 pos 迭代器失效，需要更新pos
		pos = _start + len;
	}

	//2. 挪动数据
	iterator end = _finish - 1;//_finish是有效元素的下一个位置
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = val;
	_finish++;
	//返回pos是为了解决迭代器失效问题
	//让用户可以在外部更新迭代器的位置
	return pos;
}

在这里插入图片描述

4. erase

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
	iterator end = pos + 1;
	while (end != _finish)
	{
		*(end - 1) = *(end);
		++end;
	}
	_finish--;
	return pos;//解决迭代器失效问题
}

五、vector的空间操作

1. reserve的深浅拷贝问题

reserve的原型是void reserve(size_t n)，我们知道当n > capacity时才需要对容器进行扩容，扩容必须经历『重新配置空间、移动元素、释放原空间』。

void reserve(size_t n)
{
	if (n > capacity())
	{
		int oldSize = size();//原size
		//1. 重新配置空间
		T* tmp = new T[n];
		//2. 移动元素
		//_start不为空才拷数据
		if (_start)
		{
			// 不能用memcpy，如果是自定义类型会发生错误
			// memcpy是浅拷贝
			//memcpy(tmp, _start, sizeof(T) * oldSize); 
			
			for (int i = 0; i < oldSize; ++i)
			{
				//调用赋值运算符重载完成深拷贝
				tmp[i] = _start[i];	
			}
			//3. 释放原空间
			delete[] _start;
		}
		_start = tmp;
		_finish = tmp + oldSize;//更新为原来对应位置
		_endOfStorage = _start + n;
	}

第一步和第三步都比较简单，而容易出现错误的地方是第二步将原空间的元素拷贝到新空间，假设模拟实现vector中的reserve接口时，使用memcpy进行拷贝，以下代码会发生什么问题？

void test()
{
	nb::vector<std::string> v;
	v.push_back("1111");
	v.push_back("2222");
	v.push_back("3333");
	v.push_back("4444");
	v.push_back("5555");
	//test结束时需要析构v
}
int main()
{
	test();
	return 0;
}

运行程序，程序会崩溃。

我们在push_back中使用reserve扩容，第一次扩容_start是nullptr，我们加了if判断不会使用memcpy，就算没有if判断，拷贝0字节memcpy不会做任何事。

第一次扩容后容量被初始化为4，前4次程序不会崩溃，当第五次push_back时发生第二次扩容。

前4次插入操作后v的内存图：

在这里插入图片描述

插入"5555"期间发生第二次扩容：

1.重新配置空间

在这里插入图片描述

  1. 拷贝元素：使用memcpy拷贝
    在这里插入图片描述
  2. 释放原空间

在这里插入图片描述

这样tmp中的_str变成了野指针，其指向一块已经释放了的空间，test函数结束时v发生析构，进而string对象析构对_str进行delete，此时发生错误。解决办法是调用赋值运算符重载完成深拷贝。

总结：

  1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
  2. 如果拷贝的是非自定义类型（int、double）的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，会引起内存泄漏甚至程序崩溃，因为memcpy的拷贝实际是浅拷贝。

2. resize实现

void resize(size_t n, const T& value = T())
{
	if (n > capacity())
	{
		reserve(n);
	}
	if (n > size())
	{
		while (_finish < _start + n)
		{
			*_finish = value;
			_finish++;
		}
	}
	else
	{
		_finish = _start + n;
	}
}

整体代码

#pragma once

#include <assert.h>
namespace nb
{
	template<class T>
	class vector
	{
	public:

		// vector的迭代器是一个原生指针

		typedef T* iterator;

		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}

		iterator begin() const
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		iterator end() const
		{
			return _finish;
		}

		const_iterator cbegin() const
		{
			return _start;
		}

		const_iterator cend() const
		{
			return _finish;
		}

		// construct and destroy

		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
		}

		vector(int n, const T& value = T())
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				_start[i] = value;
			}
		}

		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			//精简复用
			vector<T> tmp(v.cbegin(), v.cend());//需要调用const版本的begin、end
			swap(tmp);
		}

		vector<T>& operator= (vector<T> v)
		{
			swap(v);
			return *this;
		}

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

		// capacity

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

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

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

		void clear()
		{
			_finish = _start;
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				int oldSize = size();//原size
				T* tmp = new T[n];
				//memcpy(tmp, _start, sizeof(T) * oldSize); // --> 不能用memcpy，如果是自定义类型会发生错误
				// memcpy是浅拷贝
				//_start不为空才需要拷数据
				if (_start)
				{
					for (int i = 0; i < oldSize; ++i)
					{
						tmp[i] = _start[i];//调用赋值运算符重载完成深拷贝
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = tmp + oldSize;
				_endOfStorage = _start + n;
			}
		}

		void resize(size_t n, const T& value = T())
		{
			if (n > capacity())
			{
				reserve(n);
			}
			if (n > size())
			{
				while (_finish < _start + n)
				{
					*_finish = value;
					_finish++;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

		///access///

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

		const T& operator[](size_t pos) const
		{
			assert(pos < _finish);
			//return *(_start + pos);
			return _start[pos];
		}

		///modify/

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

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

		void swap(vector<T>& v)
		{
			//交换成员
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endOfStorage, v._endOfStorage);
		}

		// 迭代器失效 : 扩容引起，野指针问题
		iterator insert(iterator pos, const T& val)//在pos位置前面插入
		{
			assert(pos >= _start);
			assert(pos < _finish);
			//检查容量
			if (_finish == _endOfStorage)
			{
				size_t len = pos - _start;
				size_t newCapacity = _endOfStorage == 0 ? 4 : 2 * capacity();
				reserve(newCapacity);
				//扩容会导致 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 end = pos + 1;
			while (end != _finish)
			{
				*(end - 1) = *(end);
				++end;
			}
			_finish--;
			return pos;
		}

	private:

		iterator _start; // 指向数据块的开始

		iterator _finish; // 指向有效数据的尾

		iterator _endOfStorage; // 指向存储容量的尾
	};
}
二木 同学
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C++详解】——vector模拟实现
weixin_69519040的博客
11-23 692
本文首先简单介绍了vector，随后模拟实现了vector。 解决了模拟实现过程中，reserve扩容时导致的问题，insert和erase过程中迭代器失效问题，构造函数复用迭代器构造以及构造n个val值时出现的问题，拷贝构造函数中对于自定义类型的处理。
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,...
C++ vector模拟实现
最新发布
Wzs040810的博客
01-10 3627
C++ STL vector模拟实现
C++vector模拟实现增删改查
weixin_41368411的博客
04-27 2050
一.成员变量 vector的成员变量有三个，分别是三个类模板参数类型的指针_start，_finish，_endofstorage，它们分别指向vector数组的首个元素，结尾元素的下一个空间，空间末尾。 二.构造函数（默认构造，拷贝构造函数，赋值重载函数，迭代器实现构造函数） vector() :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) {} //使用迭代器完成构造函数，初.
【C++】vector模拟实现
VHhhbb的博客
07-15 972
【C++】vector模拟实现
[C++]vector模拟实现
weixin_52345097的博客
03-05 1135
C++vector模拟实现
【C++】vector 模拟实现
m0_51064412的博客
08-05 1407
文章目录一.vector介绍二. vector的模拟实现1. private成员变量及迭代器2. 容量操作接口2.1 size和capacity2.2 reserve2.2 resize3. 默认成员函数3.1 构造函数3.2 拷贝构造3.3 赋值重载4. 修改操作接口4.1 insert4.2 erase 一.vector介绍 vector是表示可变大小数组的序列容器 就像数组一样，vector也采用连续的存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不
C++vector的模拟实现
weixin_59112191的博客
04-29 1585
文章目录vector框架默认构造函数有参构造函数sizecapacity内置数据类型的构造函数const修饰的匿名对象reserveresize迭代器拷贝构造函数传统写法拷贝构造函数现代写法findinsert迭代器失效erase vector框架 template <class T> class vector { public: T _start;//(1) T _finsih;//(2) T _endofstorge;//(3) };   (1)(1)(1)指向当前空间的第一个
C++ 模拟实现vector
Han同学
12-10 2150
C++模拟实现vector
C++入门之vector的模拟实现
cls的博客
03-26 1120
vector源代码的大致框架,vector本质就是一个模板类 vector的成员变量不再是我们熟悉的size，capacity，而是变成了功能一致的三个指针 namespace pxl { template<class T> class vector { public: typedef T* iterator; private: iterator _start; iterator _finish; iterator _endofstora.
【C++】STL——vector模拟实现
M的博客
06-20 1374
vector的模拟实现
C++模拟实现vector
03-07
C++模拟实现vector
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
C++的Vector实现.zip
08-20
本项目的目标是实现一个自定义的`Myvector`类，模拟`std::vector`的部分功能。 `std::vector`的核心特性包括： 1. 动态增长：当向vector中添加元素，且当前容量不足时，vector会自动分配更大的内存空间并复制现有...
模拟vector的简易实现
07-21
下面我们将深入探讨`vector`的关键特性，并提供一个简单的模拟实现。 1. **动态内存分配**： `std::vector`的一个主要特点是它能够根据需要动态地增加或减少容量。在C++中，这通常通过调用`new`和`delete`操作符来...
Vector各个接口模拟实现
08-27
Vector各个接口模拟实现
C++ 模拟实现signal/slot
10-22
然而，C++标准库并没有内置这样的功能，所以开发者需要自行模拟实现这一机制。下面我们将深入探讨如何在C++中模拟实现信号与槽。 首先，理解信号和槽的概念是关键。信号（Signal）通常表示一个事件的发生，例如按钮...
vector 模拟实现
03-20
在本模拟实现中，我们将探讨如何根据《C++ Primer》一书中的指导，创建一个基本的`vector`类，关注其核心功能，如内存管理、动态增长和STL（标准模板库）接口的兼容性。以下是对这个模拟实现的一些关键知识点的详细...
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
c++模拟实现vector
09-01
- *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

二木 同学

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

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

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

打赏作者

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

抵扣说明：

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

余额充值