【C++标准模版库】模拟实现vector+迭代器失效问题

最新推荐文章于 2024-09-06 08:50:54 发布
最新推荐文章于 2024-09-06 08:50:54 发布
阅读量1.3k 收藏 61
点赞数 88
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2203_76003626/article/details/140864704
版权

模拟实现vector

一.vector成员变量

成员变量：

  1. iterator _start：指向vector的起始位置。
  2. iterator _finish：指向vector的最后一个有效数据的下一个位置。
  3. iterator _end_of_storage：指向vector可容纳最大数据个数的下一个位置。

大体结构如下：

在这里插入图片描述

namespace xzy
{
	//有模版不能分离到.h与.cpp文件，否则报链接错误
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

二.构造函数

1.无参（默认）构造

类内函数拷贝构造，系统就不再提供默认构造，无法vector<int> v; 需要自己提供默认构造，C++11中vector() = default; 强制生成默认构造。

//C++11 强制生成默认构造
//vector() = default;

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

2.有参构造

  1. 迭代器区间构造：例如用list对象的迭代器区间构造vector对象。作用：例如由于list对象排序性能较低，利用vector的迭代器区间初始化list对象中相同的数据进行排序，可以提高性能。
//类模版的成员函数可以是函数模版
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}
int main()
{
	list<int> l1(10, 1); //数据类型要求匹配，例如：都是int
	vector<int> v1(l1.begin(), l1.end());
}
  1. n个值为val初始化：
vector(size_t n, const T& val = T())
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}

在这里插入图片描述

解决办法：

在这里插入图片描述

3.拷贝构造

1.传统写法

vector(const vector<T>& v)
{
	_start = new T[v.capacity()];
	//memmove(_start, v._start, v.size() * sizeof(T));
	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进行尾插。

vector(const vector<T>& v)
{
	reserve(v.size());
	for (auto& e : v)
	{
		push_back(e);
	}
}

2.现代写法

void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_end_of_storage, v._end_of_storage);
}

vector(const vector<T>& v)
{
	vector<T> tmp(v.begin(), v.end());
	swap(tmp);
}

三.vector对象的容量操作

1.size

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

2.capacity

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

3.clear

void clear()
{
	_finish = _start;
}

4.empty

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

5.reserve

扩容时：先开辟新空间，再将旧空间拷贝到空间，释放旧空间，最后修改数据。

但是这里存在一个坑，如下：

在这里插入图片描述

初始_start 和 _finish 为缺省值 nullptr。
_finish = _start + size() = _start + _finish - _start = _finish = nullptr——>程序崩溃。

正确代码如下：

void reserve(size_t n)
{
	//第一种解决方法
	//if (n > capacity())
	//{
	//	T* tmp = new T[n];
	//	memmove(tmp, _start, sizeof(T) * size());
	//	delete[] _start;
	//	_finish = tmp + size();
	//	_start = tmp;
	//	_end_of_storage = _start + n;
	//}

	//第二种解决方法
	//if (n > capacity())
	//{
	//	size_t old_size = size();
	//	T* tmp = new T[n];
	//	memmove(tmp, _start, sizeof(T) * size());
	//	delete[] _start;
	//	_start = tmp;
	//	_finish = _start + old_size;
	//	_end_of_storage = _start + n;
	//}

	//第三种解决方法
	if (n > capacity())
	{
		//先保存有效数据个数
		size_t old_size = size();
		//开空间
		T* tmp = new T[n];
		//拷贝数据
		for (size_t i = 0; i < old_size; i++)
		{
			tmp[i] = _start[i];
		}
		//释放旧空间
		delete[] _start;
		//更新数据
		_start = tmp;
		_finish = _start + old_size;
		_end_of_storage = _start + n;
	}
}

但是第一种与第二种方法在某些vector容器数据为自定义类型时存在浅拷贝问题如下图：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
同理：拷贝构造使用的memmove也存在此问题。

6.resize

修改有效数据的个数时：若传入的参数小于有效数据的个数：删除数据即修改_finish即可；若传入的参数大于有效数据的个数：插入数据前考虑是否扩容。

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

在这里插入图片描述

四.vector对象的访问及遍历操作

1.operator[]

T& operator[](size_t i)
{
	assert(i >= 0 && i < size());
	return _start[i];
}

const T& operator[](size_t i) const
{
	assert(i >= 0 && i < size());
	return _start[i];
}

2.实现迭代器：begin+end

typedef T* iterator;
typedef const T* const_iterator;

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

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

五.vector对象的增删查改操作

1.operator

1.传统写法

vector<T>& operator=(const vector<T>& v)
{
	if (this != &v)
	{
		delete[] _start;
		
		_start = new T[v.capacity()];
		//memcpy(_start, v._start, v.size() * sizeof(T)); //当vector<string>时存在问题
		for(size_t i = 0; i < v.size(); i++)
		{
			_start[i] = v._start[i];
		}
		_finish = _start + v.size();
		_end_of_storage = _start + v.capacity();
	}
	return *this;
}

更好的写法：遍历vector进行尾插。

vector<T>& operator=(const vector<T>& v)
{
	if (this != &v)
	{
		clear();
		reserve(v.size());
		for (auto& e : v)
		{
			push_back(e);
		}
	}
	return *this;
}

2.现代写法

void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_end_of_storage, v._end_of_storage);
}

//类内可以用类名替代类型：vector& operator=(vector tmp)
vector<T>& operator=(vector<T> tmp)
{
	swap(tmp);
	return *this;
}

2.push_back

尾插时：先检查容量，再进行尾插。

void push_back(const T& x)
{
	//容量满了——>扩容
	if (_finish == _end_of_storage)
	{
		reserve(capacity() == 0 ? 4 : 2 * capacity());
	}
	//尾插
	*_finish = x;
	++_finish;
}

3.pop_back

尾删时：先检查是否有有效数据，再进行尾删。

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

4.insert

插入时：先检查容量，再整体右移一位，最后插入。

迭代器失效：类似野指针

实现插入操作有一个坑造成迭代器失效问题，如下图：

在这里插入图片描述

修改后的代码能解决上面的问题，但是又存在另一个迭代器失效的问题，如下图：

在这里插入图片描述

迭代器失效：位置意义改变

在这里插入图片描述

由于不知道insert函数内是否存在扩容，不能确保pos是否为野指针，解决方法：可以在insert函数中返回pos用于接受。代码如下：

iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	
	//容量满了——>扩容
	if (_finish == _end_of_storage)
	{
		//记录pos的相对位置防止迭代器失效
		size_t len = pos - _start;
		reserve(capacity() == 0 ? 4 : 2 * capacity());
		pos = _start + len;
	}
	//整体后移一位
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	//插入数据
	*pos = x;
	++_finish;
	
	return pos;
}

5.erase

同理erase也会遇到的迭代器失效：位置意义改变，在vs2022中的vector（SLT）不接收erase的返回值强行访问，程序崩溃。接收erase的返回值访问，程序正常运行。

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
	
	iterator it = pos + 1;
	while (it != end())
	{
		*(it - 1) = *it;
		++it;
	}
	--_finish;
	
	return pos;
}

实现删除vector中的偶数：

int main()
{
	std::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

	auto it = v1.begin();
	while (it != v1.end())
	{
		if (*it % 2 == 0)
		{
			it = v1.erase(it);
		}
		else
		{
			it++;
		}
	}
	return 0;
}

六.源代码

1.vector.h

//#pragma once

#ifndef __VECTOR_H__
#define __VECTOR_H__

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

namespace xzy
{
	//有模版不能分离到.h与.cpp文件，否则报链接错误
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		//C++11 强制生成默认构造
		//vector() = default;

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

		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];
			//memmove(_start, v._start, v.size() * sizeof(T)); //当vector<string>时存在问题
			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(const vector<T>& v)
		{
			reserve(v.size());
			for (auto& e : v)
			{
				push_back(e);
			}
		}*/

		//类模版的成员函数可以是函数模版
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

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

		void clear()
		{
			_finish = _start;
		}

		//vector<T>& operator=(const vector<T>& v)
		//{
		//	if (this != &v)
		//	{
		//		delete[] _start;
		//		_start = new T[v.capacity()];
		//		//memcpy(_start, v._start, v.size() * sizeof(T));//当vector<string>时存在问题
		//      for(size_t i = 0; i < v.size(); i++)
		//        {
		//			  _start[i] = v._start[i];
		//        }
		//		_finish = _start + v.size();
		//		_end_of_storage = _start + v.capacity();
		//	}
		//	return *this;
		//}

		//vector<T>& operator=(const vector<T>& v)
		//{
		//	if (this != &v)
		//	{
		//		clear();
		//		reserve(v.size());
		//		for (auto& e : v)
		//		{
		//			push_back(e);
		//		}
		//	}
		//	return *this;
		//}

		void swap(vector<int>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}

		类内可以用类名替代类型：vector& operator=(vector tmp)
		vector<T>& operator=(vector<T> tmp)
		{
			swap(tmp);
			return *this;
		}

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

		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())
		//	{
		//		//开空间
		//		T* tmp = new T[n];
		//		//拷贝数据
		//		memmove(tmp, _start, sizeof(T) * size());
		//		//释放旧空间
		//		delete[] _start;
		//		//更新数据
		//		_start = tmp;
		//		_finish = _start + size(); 注意：size()已经不再是有效数据个数了，可以通过调试观察
		//		_end_of_storage = _start + n;
		//	}
		//}

		void reserve(size_t n)
		{
			//第一种解决方法：依旧存在错误
			//if (n > capacity())
			//{
			//	T* tmp = new T[n];
			//	memmove(tmp, _start, sizeof(T) * size());
			//	delete[] _start;
			//	_finish = tmp + size();
			//	_start = tmp;
			//	_end_of_storage = _start + n;
			//}

			//第二种解决方法：依旧存在错误
			/*if (n > capacity())
			{
				size_t old_size = size();
				T* tmp = new T[n];
				memmove(tmp, _start, sizeof(T) * size());
				delete[] _start;
				_start = tmp;
				_finish = _start + old_size;
				_end_of_storage = _start + n;
			}*/

			//第三种解决方法
			if (n > capacity())
			{
				//先保存有效数据个数
				size_t old_size = size();
				//开空间
				T* tmp = new T[n];
				//拷贝数据
				for (size_t i = 0; i < old_size; i++)
				{
					tmp[i] = _start[i];
				}
				//释放旧空间
				delete[] _start;
				//更新数据
				_start = tmp;
				_finish = _start + old_size;
				_end_of_storage = _start + n;
			}
		}

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

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

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

		void push_back(const T& x)
		{
			//容量满了——>扩容
			if (_finish == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : 2 * capacity());
			}
			//尾插
			*_finish = x;
			++_finish;
		}

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

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

		//void insert(iterator pos, const T& x)
		//{
		//	//容量满了——>扩容
		//	if (_finish == _end_of_storage)
		//	{
		//		reserve(capacity() == 0 ? 4 : 2 * capacity());
		//	}
		//	//整体后移一位
		//	iterator end = _finish;
		//	while (end > pos)
		//	{
		//		*end = *(end - 1);
		//		--end;
		//	}
		//	//插入数据
		//	*pos = x; //pos为野指针，迭代器失效
		//	++_finish;
		//}

		iterator insert(iterator pos, const T& x)
		{
			//容量满了——>扩容
			if (_finish == _end_of_storage)
			{
				//记录pos的相对位置防止迭代器失效
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : 2 * capacity());
				pos = _start + len;
			}
			//整体后移一位
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			//插入数据
			*pos = x;
			++_finish;

			return pos;
		}

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

			return pos;
		}

		T& operator[](size_t i)
		{
			assert(i >= 0 && i < size());
			return _start[i];
		}

		const T& operator[](size_t i) const
		{
			assert(i >= 0 && i < size());
			return _start[i];
		}

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;

	};
}

#endif
清风~徐~来
关注
  • 88
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 60
    评论
专栏目录
【C++】vector迭代器失效问题
进阶之路
05-04 317
vector迭代器失效问题 迭代器失效是什么？ 迭代器失效，是不能再去拿迭代器去访问vector中的元素，此时的迭代器指向的这块空间已经被释放了，也就是说此时的迭代器已经是野指针了。 insert可能会导致迭代器失效 当vector数组开辟一段的空间之后，调用insert函数，向数组中插入一个值后，有可能会导致原来的空间不足，这时候，vector要进行深拷贝，就会开辟一个更大的空间，将原来空间上的...
C++中vector迭代器失效问题及其解决方法
weixin_61556366的博客
09-07 1090
C++迭代器失效问题
【C++标准模版库】模拟实现list+迭代器失效问题
2203_76003626的博客
08-05 1063
模拟实现list
从C语言到C++_15(vector的模拟实现)+迭代器失效问题
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
06-03 1267
从C语言到C++_15（vector的模拟实现）完整代码+迭代器类型介绍+迭代器失效问题，下一部分：list。
关于vector迭代器失效的几种情况总结
08-31
在C++标准模板库(STL)中，`std::vector`是一个非常常用的数据结构，它提供了动态数组的功能。然而，由于其动态性，当我们对`vector`进行某些操作时，可能会导致迭代器失效，这在编程中是一个需要注意的重要问题。...
【C++ STL】vector 容器（介绍、使用、@迭代器失效问题、模拟实现、动态二维数组）
codewinter的博客
05-24 984
文章目录一、STL - vector 的介绍二、vector 的使用（常用接口介绍）2.1 常见构造2.2 迭代器及遍历操作2.3 容量操作2.4 访问操作2.5 修改操作2.6 vector 迭代器失效问题（⭐重要）2.7 补充：其它接口三、源码剖析：vector 的底层结构四、vector 的模拟实现4.1 vector 的结构4.2 vector 的迭代器4.3 一些成员函数的实现① 默认成员函数② 容量操作使用 memcpy 浅拷贝的问题（⭐）解决 memcpy 浅拷贝的问题（⭐）③ 访问操作④ 修
【C++】vector的模拟实现 | 使用memcpy拷贝时的问题 | 实现深拷贝 | 迭代器失效问题
2301_76540463的博客
10-06 597
上一篇我们说到了vector，它是一个类模板，能够容纳各种类型的对象作为其元素，并且可以动态地调整大小。可以理解为动态数组。这篇我们就亲自实现一下 简易版的vector，这能大大加深我们对vector的理解！而因为vector的实现和string有很多相似之处，所以实现过程中的一些细节便不再详述。
C++ STL - list 模拟实现+解析迭代器
TPON的博客
10-12 967
STL - list iterator const_iterator reverse_iterator 模拟实现
C++迭代器失效
倒地不起的土豆
06-27 3364
迭代器失效就是迭代器底层对应指针所指向的空间倍销毁了，导致使用了一块已经被释放了的空间。 容器操作可能使迭代器失效，一个失效的迭代器将不再表示任何元素。使用失效的迭代器是一个严重的程序设计错误，很可能产生与使用未初始化化指针一样的问题。.........
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1390
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
C++红黑树的底层原理及其实现原理和实现
2302_80214413的博客
09-02 905
今天给大家带来的是红黑树的底层逻辑和底层实现原理及其实现过程，相信大家看完一定会收获满满！~~~
C/C++ 获取 linux 的所有 USB声卡ID及其信息
lijian2017的博客
09-04 1142
popen()在 Linux 下，要获取 USB 声卡的 ID 和名称信息，通常你需要结合多个系统命令和接口，因为 C/C++ 标准库本身并不直接提供这样的功能。下面我将给出一个大致的方向，展示如何通过执行系统命令或使用 Linux 特有的库来实现这一目标。
Linux C 内核编程 /proc 编程例子
yong1585855343的博客
09-02 504
Linux 内核编程 /proc 例子代码
Qt/C++ 个人开源项目#串口助手（源码与发布链接）
最新发布
填坑之路
09-06 603
该串口助手提供了编译好的发布包，用户可以自行下载可以直接启动应用。在应用界面中，选择要连接的串口设备，配置相关串口参数，点击“连接”即可开始数据通信。工具具有直观的用户界面和丰富的功能，旨在帮助用户与串口设备建立可靠通信，便于调试、数据传输和分析。串口助手具备自动检测功能，可以自动识别当前系统中的串口设备。：支持实时显示从串口设备接收的数据，用户可以选择显示格式（如十六进制、ASCII等）。：用户可以通过界面输入并发送数据，支持单次发送和定时发送，便于测试连续传输。：支持无校验、奇校验、偶校验等。
C++友类匿名对象，运算符重载
m0_75109289的博客
09-02 266
【代码】C++友类匿名对象，运算符重载。
《从C/C++到Java入门指南》- 26.record 类+多态
09-02 351
由于record类比较简单，将他和多态放在一节中。
C++竞赛初阶L1-15-第六单元-多维数组(34~35课)551: T456501 计算矩阵边缘元素之和
麓小墨哥的博客
09-03 657
所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。第 1 行包含两个整数，分别为行数 m 和列数 n，两个整数之间空格隔开。第 2 行开始有 m 行数据，每行包含 n 个整数，整数之间空格隔开。输入一个整数矩阵，计算位于矩阵边缘的元素之和。对应矩阵的边缘元素和。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 206
C++ | Leetcode C++题解之第390题消除游戏
C++编程深入解析vector容器
在C++中，`std::vector`是标准模板库（STL）中最常用的容器之一，它作为顺序容器提供高效的操作。与静态分配空间的数组不同，vector允许动态地添加或删除元素，从而改变其大小。这是因为vector在内存中分配了一块...
评论 60
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值