vector的模拟实现

于 2022-06-17 11:22:50 发布
阅读量557 收藏 9
点赞数 17
分类专栏： C++ 文章标签： c++ vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57675461/article/details/123975816
版权

文章目录

一、vector中常用类成员

namespace sjj//自定义命名空间与标准库中的以区别开来
{
	template<class T>//类模板
	class vector
	{
	public:
		typedef T* iterator;                            //类型指针
		typedef const T* const_iterator;
		vector();                                       //构造函数1
		
		template<class InputIterator>;//用一段迭代器区间去初始化，为了支持任意类型，用到了模板
		vector(InputIterator first, InputIterator last);//构造函数2

		vector(const vector<T>& v);                     //拷贝构造函数

		vector<T>& operator=(vector v);                 //赋值运算符重载

		~vector();                                      //析构函数

		//迭代器相关的函数
		iterator begin();
		const_iterator begin() const;
		iterator end();
		const_iterator end()const;


		//容量大小相关的函数
		size_t size()const;
		size_t capacity()const;
		bool empty();


		//扩容相关的函数
		void reserve(size_t n);
		void resize(size_t n, const T& val = T());

		//插入数据相关的函数
		iterator insert(iterator pos, const T& x);//在pos位置之前插入数据x
		void push_back(const T& x);               //尾插


		//删除数据相关的函数
		void pop_back();
		iterator erase(iterator pos);


		//下标访问相关的函数
		T& operator[](size_t i);
		const T& operator[](size_t i)const;

		//其他函数
		void Swap(vector<T>& v);

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};
}

二、vector的底层结构

我们就用这三个私有成员来模拟实现我们的vector

iterator _start;//开始位置的指针
iterator _finish;//结束的下一个位置的指针
iterator _endofstorage;//最大容量的下一个位置的指针

在这里插入图片描述

三、vector的默认成员函数

构造函数1—空构造

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

构造函数2—迭代器区间构造

//用一段迭代器区间去初始化，为了支持任意类型，用到了模板
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 = new T[v.capacity()];
	_finish = _start + v.size();
	_endofstorage = _start + v.capacity();
	
	//void * memcpy ( void * destination, const void * source, size_t num );
	memcpy(_start,v._start,sizeof(T)*v.size());
}

写法二：现代写法（更推荐）

//现代写法
vector(const vector<T>& v)//v是一个局部对象，出了作用域自动调用析构函数，不用管它
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	vector<T> tmp(v.begin(), v.end());//利用迭代器区间进行初始化tmp
	Swap(tmp);//交换this对象和tmp对象里面的值
}

赋值运算符重载

写法一：传统写法

//传统写法
vector<T>& operator=(const vector<T>& v)
{
	if (this != &v) //防止自己给自己赋值
	{
		delete[] _start; //释放原来的空间
		_start = new T[v.capacity()]; //新开辟一块和容器v大小相同的空间
		for (size_t i = 0; i < v.size(); i++) //将容器v当中的数据一个个拷贝过来
		{
			_start[i] = v[i];
		}
		_finish = _start + v.size(); //更新_finish
		_endofstorage = _start + v.capacity(); //更新_endofstorage
	}
	return *this; //支持连续赋值，返回引用
}

写法二：现代写法(更加推荐)

vector<T>& operator=(vector v)
{
	Swap(v);
	return *this;//为了支持连续赋值，返回引用
}

析构函数

//析构
~vector()
{
	delete[] _start;
	_start = _finish = _endofstorage = nullptr;
}
//全部置空

四、迭代器相关的函数

迭代器的分类

在这里插入图片描述
每一种迭代器都有着命名的规范，我们可以通过英文见名知意。
每一个迭代器越往上，权限就越小，我们可以把下面的迭代器看做父类，越往上的迭代器就是子类，它们有着父类的相关操作，但是我们传入迭代器时，只能传入权限大于等于当前迭代器的类型,例如我们reverse函数，需要传入双向迭代器，它可以传双向、随机，但是不能传权限比他小的迭代器，否则就会报错
通过查看文档我们可以看到一些函数需要传入迭代器类型：
在这里插入图片描述

迭代器对应的STL容器分类

在这里插入图片描述
举个例子：

int main()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(4);
	v1.push_back(3);
	v1.push_back(6);
	sort(v1.begin(), v1.end());//正确使用

	list<int> lt;
	lt.push_back(1);
	lt.push_back(3);
	lt.push_back(2);
	lt.push_back(4);
	sort(lt.begin(),lt.end());//这里会报错
	return 0;
}

list使用的是双向迭代器，sort要求传入随机迭代器，权限被缩小了，这是错误的使用

迭代器失效问题

问题引出：

void insert(iterator pos, const T& x)
{
	assert(pos >= _start && pos <= _finish);//暴力检查
	if (_finish == _endofstorage)//检查是否需要扩容
	{
		reserve(capacity() == 0 ? 4 : capacity() * 2);
	}
	//插入x
	iterator end = _finish - 1;
	while (end>=pos)
	{
		*(end +1) = *end;//前一个挪到后一个位置
		--end;
	}
	*pos = x;
	++_finish;
}
//测试
void test()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	vector<int>::iterator it = find(v.begin(), v.end(), 2);//找到值为2的位置
	if (it != v.end())
	{	// 如果insert中发生了扩容，那么会导致it指向空间被释放
		// it本质就是一个野指针，这种问题，我们就叫迭代器失效
		v.insert(it, 20);
	}
	for (auto e : v)
	{
		cout << e << " ";
	}
}

在这里插入图片描述
怎么造成迭代器失效的呢？

原因：插入数据扩容的时候，我们定义了一个pos位置和end位置两个迭代器，新空间中，没有pos位置，但是原来的就空间还有个pos迭代器，任然指向一个已经被返还给操作系统的空间，但是最后居然*pos，解引用插入数据了，这显然是个野指针问题，存在着内存泄漏的风险。

改正解决迭代器失效的办法：在使用前，对迭代器重新进行赋值即可，我们需要更新一下扩容后的新的pos位置，并且我们在外部传参时，形参的改变不会影响实参，所以我们要传insert的pos位置的返回值，我们才能真正的删除pos位置的数据

//在pos位置之前插入数据x
iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start);//暴力检查
	assert(pos <= _finish);
	if (_finish == _endofstorage)//检查是否需要扩容
	{
		//扩容会导致pos位置迭代器失效，所以需要更新一下新位置的pos
		size_t len = pos - _start;//记录一下pos距离_start位置的长度
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		pos = _start + len;//更新一下扩容后的pos
	}

	//插入x
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = x;
	++_finish;

	return pos;//返回新空间pos位置，因为形参的改变不会影响实参
}

同样erase中也存在着迭代器失效的问题

void erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	iterator begin = pos + 1;//pos的下一个位置记作begin
	while (begin < _finish)
	{
		*(begin - 1) = *begin;//数据从后往前覆盖
		++begin;
	}

	--_finish;//数据个数减一，finish也减一
}
void test()
{
	// 三种场景去测试
	// 1 2 3 4 5 -> 正常
	// 1 2 3 4   -> 崩溃
	// 1 2 4 5   -> 没删除完
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(4);
	v1.push_back(5);
	//v1.push_back(5);
	// 要求删除v1所有的偶数
	vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		if (*it % 2 == 0)
		{
			v1.erase(it);
		}

		++it;
	}
	}

	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
}

在这里插入图片描述
在这里插入图片描述
这里最大的问题就是，erase(it)后，it的意义已经变了，就是迭代器失效了，直接++it可能不导致一些意料之外的结果，如果是连续的偶数，会直接跳过后一个偶数，导致后一个偶数没有被删除掉。

正确的erase函数：

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	iterator begin = pos + 1;//pos的下一个位置记作begin
	while (begin < _finish)
	{
		*(begin - 1) = *begin;//数据从后往前覆盖
		++begin;
	}

	--_finish;//数据个数减一，finish也减一

	return pos;//传pos位置的迭代器，防止迭代器失效
}
void test()
{
	// 三种场景去测试
	// 1 2 3 4 5 -> 正常
	// 1 2 3 4   -> 崩溃
	// 1 2 4 5   -> 没删除完
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(4);
	v1.push_back(5);
	vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		if (*it % 2 == 0)
		{
			it = v1.erase(it);//传it位置的返回值，更新pos位置，这样就不会导致迭代器失效的问题了
		}
		else
		{
			++it;
		}
	}

	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
}

迭代器相关的函数

其实vector中的迭代器就是原生类型的指针，只不过是经过typedef的

typedef T* iterator;
typedef const T* const_iterator;

begin()和end()函数

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

const版本的begin()和end()函数

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

五、vector中容量大小相关的函数

我们这里就可以利用C语言学到的，两个指针的差值就是两个指针指向间的元素个数

size()函数

size_t size()const
{
	return _finish - _start; //返回容器当中有效数据的个数
}

capacity()函数

size_t capacity()const
{
	return _endofstorage - _start; //返回当前容器的最大容量
}

empty()函数

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

六、vector中扩容相关的函数

reserve()函数

void reserve(size_t n)
{
	if (n > capacity())
	{
		//扩容
		size_t sz = size();
		T* tmp = new T[n];//新开一段空间
		if (_start)
		{
			//void* memcpy(void* dest, const void* src, size_t count);
			memcpy(tmp, _start, sizeof(T) * size());//memcpy是浅拷贝，数据是内置类型不影响，是自定义类型会崩溃
			delete[] _start;//释放掉原来的空间
		}
		_start = tmp;//交换指针指向
		//扩完容以后_finsih  _endodstorage也要处理一下
		//要把原来的size保存一下
		//_finish = _start + size();//size=finish-start start已经被更新了
		_finish = _start + sz;
		_endofstorage = _start + n;
	}
}

使用memcpy拷贝问题

我们这里如果vector中存入的是string等自定义类型，使用memcpy进行拷贝，会出现什么问题呢？

int main()
{
	sjj::vector <string> v;
	v.push_back("11111111111111111");
	v.push_back("11111111111111111");
	v.push_back("11111111111111111");
	v.push_back("11111111111111111");
	return 0;
}

问题分析：

  1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
  2. 如果拷贝的是内置类型的元素，memcpy即高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。
  3. 插入的字符串长一些的话，就会出现乱码
    在这里插入图片描述

在这里插入图片描述
结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。
我们作出的改变就是不用memcpy，我们手动将数据一个一个的拷贝过去。我们能够间接调用string的赋值运算符重载，实现string的深拷贝。
出现乱码：VS下作了一个优化，当数据字长较小时(小于16时)，它会把数据存入一个char _Buf[16]的数组中，当数据长一点，它会把数据存入一个堆上开辟的大数组中char * _ptr中。

//代码修正
//memcpy(tmp, _start, sizeof(T) * size());//memcpy是浅拷贝
for (size_t i = 0; i < sz; ++i)
{
	//当T是int等内置类型，一个一个拷贝没有问题
	//当T是string等内置类型，会去调用它的深拷贝
	tmp[i] = _start[i];
}

resize()函数

我们这里需要考虑两种情况
第一种：
在这里插入图片描述
第二种：
在这里插入图片描述

void resize(size_t n, const T& val = T())// 给T()缺省值，int() 
{
	//分两种情况
	//第一种n<size
	//第二种n>capacity需要扩容
	if (n < size())
	{
		_finish = _start + n;
	}
	else
	{
		if (n > capacity())
		{
			reserve(n);
		}
		while (_finish != _start + n)
		{
			*_finish = val;
			++_finish;
		}
	}
}

七、vector的增加数据相关的函数

push_back( )

void push_back(const T& x)
{
	if (_finish == _endofstorage)
	{
	   	//复用reserve函数
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		//如果当前的capacity是0，扩到4，如果不是0，就扩2倍
	}
	*_finish = x;
	++_finish;
}

insert()函数

//在pos位置之前插入数据x
iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start);//暴力检查
	assert(pos <= _finish);
	if (_finish == _endofstorage)//检查是否需要扩容
	{
		//扩容会导致pos位置迭代器失效，所以需要更新一下新位置的pos
		size_t len = pos - _start;//记录一下pos距离_start位置的长度
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		pos = _start + len;//更新一下扩容后的pos
	}

	//插入x
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = x;
	++_finish;

	return pos;//返回新空间pos位置，因为形参的改变不会影响实参
}

八、vector的删除数据相关的函数

pop_back()函数

void pop_back()
{
	assert(_finish > _start);//暴力检查一下，防止越界
	--_finish;//将_finish减减，相当于就把尾上的数据删除了
}

erase()函数

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	iterator begin = pos + 1;//pos的下一个位置记作begin
	while (begin < _finish)
	{
		*(begin - 1) = *begin;//数据从后往前覆盖
		++begin;
	}

	--_finish;//数据个数减一，finish也减一

	return pos;//传pos位置的迭代器，防止迭代器失效
}

九、vector的查找数据相关的函数

operator[ ]下标查找

//普通版本
T& operator[](size_t i)
{
	assert(i < size());
	return _start[i];
}
//const版本
const T& operator[](size_t i)const
{
	assert(i < size());
	return _start[i];
}

十、其他函数

swap()函数

void Swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstorage, v._endofstorage);
}
Hero 2021
关注
  • 17
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
vector模拟实现
liuming
10-09 187
vector就是一个动态的顺序表，可以存放任何元素，其中使用三个指针（start，finish，end_of_storage）进行实现，本文将实现5个模块中常用的的接口。 此图大致为vector的结构。 首先声明迭代器以及维护的指针： typedef T* Itreator; private: Itreator start; Itreator finish; Itreator end_of_storage; 一、构造和析构 本文实现四种构造方法； （1）无参构造：对三个指.
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++STL详解（四）—— vector的模拟实现
2021dragon的博客
08-03 2928
vector的模拟实现
【vector的模拟实现】
Willing_hope的博客
08-06 176
1、构造函数 //无参构造 vector() :_start(nullptr), _finish(nullptr), _endofstorage(nullptr) {} //拷贝构造1 vector(const vector<T>&v) { _start = new T[v.capacity()]; _finish = _start + v.size(); _endofstorage = _start + v.capacity();
模拟实现vector
弯弯传奇的博客
01-27 378
继之前的vector的用法总结之后，简单实现的vector。测试代码只写了一部分，再就是有个问题，在linux环境下编译nullptr会报错（未声明）？求指教 using namespace std; template&amp;lt;class T&amp;gt; class Vector { public: typedef decltype(nullptr) nullptr_t; typed...
vector 模拟实现
03-20
在本模拟实现中，我们将探讨如何根据《C++ Primer》一书中的指导，创建一个基本的`vector`类，关注其核心功能，如内存管理、动态增长和STL（标准模板库）接口的兼容性。以下是对这个模拟实现的一些关键知识点的详细...
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
C++ vector模拟实现
a1299960335的博客
04-10 182
模拟实现C++ vectorvector 介绍vector各类接口一般接口函数增删查改函数vector样图模拟实现代码 vector 介绍 vector是表示可变大小数组的序列容器。 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素 进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自 动处理。 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小 为了增加存储空间。其做
模拟实现Vector
zw_ss
10-14 220
Vector模拟实现，具体的Vector描述请查看https://blog.csdn.net/weixin_40853073/article/details/81413281 #include&amp;lt;iostream&amp;gt; #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;assert.h&amp;gt; using namespace std; #pragma once typ...
c++模拟实现vector
最新发布
09-01
引用和提供了关于实现vector的两种方法。其中，引用展示了一个使用reserve和push_back方法的示例，而引用展示了一个使用new和memcpy函数的示例。这两种方法都是常见的实现vector的方式。 在第一种方法中，通过reserve函数可以预留足够的内存空间，然后使用push_back函数逐个将元素添加到vector中。这种方法的好处是可以避免不必要的内存重分配，提高了效率。 而第二种方法使用new操作符在堆上分配内存空间，并使用memcpy函数将已有的vector对象的数据复制到新的内存空间中。通过这种方式，可以实现深拷贝，即两个vector对象拥有独立的内存空间。这种方法的好处是可以在不修改原始vector对象的情况下创建一个新的vector对象。 除了以上两种方法，还可以使用其他方式实现vector类。例如，可以使用动态数组来实现vector的底层数据结构，然后通过成员函数实现vector的各种操作，如增加、删除、查找等。 总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况选择。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *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_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值