【C++】STL-vector模拟实现

已于 2024-05-29 16:29:15 修改
阅读量834 收藏 11
点赞数 15
文章标签： c++ 开发语言
于 2024-04-24 14:49:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80277275/article/details/138135519
版权
本文详细介绍了vactor的模拟实现，包括vector的构造、析构、拷贝构造、成员变量、容量管理、迭代器操作以及内存拷贝问题，重点讨论了C++中的vector类、Initializer_list的使用以及浅拷贝和资源管理的注意事项。
摘要由CSDN通过智能技术生成

目录

1、vactor的模拟实现

1.1 成员变量

1.2 size、capacity

1.3 迭代器

1.4 构造、析构、拷贝构造、operator=

1.5 push_back、pop_back、reserve

1.6 operator[]

1.7 insert、erase

1.8 resize

1.9 花括号初始化的问题(C++11支持)

2、使用memcpy拷贝问题

1、vactor的模拟实现

1.1 成员变量

vector是顺序表，但是并不像之前在数据结构中一样会有一个指针动态开辟出的空间的指针、size、capacity，而是由3个指针构成的

1.2 size、capacity

1.3 迭代器

1.4 构造、析构、拷贝构造、operator=

vector的构造函数当中有一个是使用迭代器区间进行初始化的

还有一个是使用n个相同的值来进行初始化

但此时会报错，原因是v4中的两个参数都是int，而n个相同值的构造中第一个是size_t，所以会匹配到迭代器区间初始化去了，因为迭代器区间初始化更加匹配

解决方法1：传参的时候在10的后面加个 u ，表明是size_t类型

解决方法2：重载一个n是int的n个相同值的构造函数

因为类对象会开辟空间，所以要自己实现深拷贝的拷贝构造和operatpr=

此时会有一个问题，就是拷贝构造中，范围for用的是引用，传到push_back中，push_back用的也是引用，若是自定义类型，这样不会造成浅拷贝吗？

不会的，因为push_back中的*_finish = x是会去调用对应类型的赋值运算符重载的

1.5 push_back、pop_back、reserve

此时这个reserve是有问题的

1.6 operator[]

1.7 insert、erase

此时也会有迭代器失效问题，因为如果需要增容，通过reserve增完后，_start、_finish、_endofstorage都指向了新的空间，而pos仍然指向原来的空间，所以需要更新pos的位置

1.8 resize

1.9 花括号初始化的问题(C++11支持)

在前面，我们有学习过单参数的构造函数可以使用隐式类型转换来进行初始化对象

实际上，对于多参数的构造函数，一样可以使用隐式类型转换来初始化对象

我们会发现vector也有类似的操作

此时，这也是一种隐式类型转换，但与上面类A的隐式类型转换有所不同，并不是直接用花括号内的数值去构造一个临时的vector，再赋值给v1，因为若是这样的话需要实现无穷多个不同参数个数的构造函数

在C++11中,引入了一个类模板initializer_list,支持将用{}括起来的任意多个值创建initializer_list对象

编译器会自动用被{}括起来的数据区实例化出一个initializer_list对象

initializer_list是支持迭代器的

initializer_list的成员变量就是两个指针，_Fist指针指向第一个值，_Last指针指向最后一个值的下一个

所以这个的隐式类型转换实际上是先用{}里面的内容去实例化出一个initializer_list对象,再用这个对象去构造一个vector，再拷贝构造，但通常会被优化成直接用initializer_list对象去构造v1

initializer_list在使用范围for遍历时，不用加引用

{}的用法：1. 单参数、多参数的隐式类型转换，单参数通常不用

                 2. initializer_list的构造

2、使用memcpy拷贝问题

在上面的reserve中使用了memcpy，在遇到自定义类型时会出错，因为memcpy是浅拷贝

问题分析：
1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
2. 如果拷贝的是内置类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。
结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃

上面的tmp[i]=_start[i]也不一定是string的operator=，应该是T的operator=，只是这里是string的

3、进一步理解迭代器失效

会发现STL库中的vector的迭代器是一个类，并不是单纯的是一个T*的指针，它是用了一个类去封装T*，里面会有一个flag来记录迭代器是否失效，当erase后，将flag=0，在操作迭代器时，若flag==0，则会报错，因为erase可能会有缩容等等可能造成野指针的情况，所以为了绝对安全，只要erase了，就直接让flag=0。Linux下不一样是因为类中的操作不同。 

#include<iostream>
#include<cassert>
using namespace std;
template<class T>
class Vector
{
public:
	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()
		:_start(nullptr)
		,_finish(nullptr)
		,_endofstorage(nullptr)
	{}
	~Vector()
	{
		delete[] _start;
		_start = _finish = _endofstorage = nullptr;
	}
	/*Vector(const Vector<T>& v)
	{
		_start = new T[v.capacity()];
		_finish = _start;
		_endofstorage = _start + capacity();
		for (size_t i = 0; i < v.size(); i++)
		{
			*_finish = v[i];
			_finish++;
		}
	}*/
	/*Vector(const Vector<T>& v)
	{
		_start = new T[v.capacity()];
		_finish = _start + v.size();
		_endofstorage = _start + v.capacity();
		memcpy(_start, v._start, sizeof(T) * v.size());
	}*/
	Vector(const Vector<T>& v)
		:_start(nullptr)
		, _finish(nullptr)
		, _endofstorage(nullptr)
	{
		reserva(v.capacity());//防止push_back频繁扩容
		for (const auto& e : v)
			push_back(e);
	}
	//Vector<T>& operator=(const Vector<T>& v)
	//{
	//	if (this != &v)
	//	{
	//		delete[] _start;
	//		_start = new T[v.capacity()];
	//		memcpy(_start, v._start, sizeof(T) * v.size());
	//		//也可以一个一个赋值
	//	}
	//	return *this;
	//}
	void swap(Vector<T>& v)
	{
		::swap(_start, v._start);
		::swap(_finish, v._finish);
		::swap(_endofstorage, v._endofstorage);
		//这里是在局部调用全局的swap，所以前面加::
	}
	Vector<T>& operator=(Vector<T> v)
	{
		swap(v);
		return *this;
	}
	//for (size_t i = 0; i < sz; i++)
	//{
	//	tmp[i] = _start[i];//利用string的operator=的深拷贝
	//}
	void reserve(size_t n)
	{
		if (n > capacity())
		{
			size_t sz = size();//先记录_finish相对_start的偏移量
			T* tmp = new T[n];
			if (_start)
			{
				注意这里一定要判断一下，当_start是空的时候使用memcoy会报错
				且因为_start是空，也没必要将上面的内容拷贝到tmp上
				memcpy(tmp, _start, sizeof(T) * size());
				delete[] _start;
			}
			_start = tmp;
			_finish = _start + sz;
			_endofstorage = _start + n;
		}
	}
	void push_back(const T& x)//用引用是因为T可能是自定义类型
	{
		if (_finish == _endofstorage)//满了则扩容
		{
			size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
			reserve(newcapacity);
		}
		*_finish = x;
		++_finish;
		//insert(_finish, x);也可以直接复用insert
	}
	void pop_back()
	{
		assert(_start < _finish);
		//保证不为空
		_finish--;
		//erase(_finish-1);//也可复用erase
	}
	void insert(iterator pos, const T& x)
	{
		assert(pos <= _finish);
		if (_finish == _endofstorage)
		{
			size_t n = pos - _start;//计算pos相对_start的偏移量
			size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
			reserve(newcapacity);
			pos = _start + n;//更新pos的位置
		}
		iterator end = _finish - 1;
		while (end >= pos)
		{
			*(end + 1) = *end;
			end--;
		}
		*pos = x;
		_finish++;
	}
	iterator erase(iterator pos)
	{
		assert(pos < _finish);//确保删除位置有效
		iterator it = pos;
		while (it < _finish)
		{
			*it = *(it + 1);
			it++;
		}
		_finish--;
		return pos;
		//删除后原本的下一个就到了pos的位置
		//所以返回迭代器就是返回原来的位置
	}
	void resize(size_t n, const T& val = T())
	{
		//上面给的缺省值不能给0，因为不一定是int类型，T()是针对任何类型的
		//int i = int();  ->  i=0;
		//int i = int(7)  ->  i=7;
		//C++为了让内置类型可以兼容模板
		if (n <= size())//如果比size还小或等于，不用填充，直接缩小
		{
			_finish = _start + n;
		}
		else//需要填充
		{
			if (n > capacity())//扩容
			{
				reserve(n);
			}
			//填充，从_finish的位置开始向后填充
			//填充时不能用memcpy将val直接弄到_finish到_start+n的位置
			//因为memcpy是浅拷贝,若是自定义类型且开辟了空间
			//会直接让所以的都指向同一块空间
			while (_finish < _start + n)
			{
				*_finish = val;
				_finish++;
			}
		}
	}
	T& operator[](size_t i)//可读可写
	{
		assert(i < size());//断言，防止i越界
		return _start[i];
	}
	const T& operator[](size_t i) const//只可读
	{
		assert(i < size());//断言，防止i越界
		return _start[i];
	}
	size_t size() const
	{
		return _finish - _start;
	}
	size_t capacity() const
	{
		return _endofstorage - _start;
	}
private:
	iterator _start;//指向动态开辟数组的起始位置
	iterator _finish;//指向动态开辟数组的有值的下一个位置
	iterator _endofstorage;//指向动态开辟数组的末尾
};

升级版

#pragma once
#include<iostream>
#include<algorithm>
#include<assert.h>
#include<initializer_list>
namespace cxf
{
	template<class T>
	class vector
	{
	public:
		//迭代器相关
		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()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}
		// 构造函数还可以使用迭代器区间进行初始化
		// 在类模板的内部也可以定义类函数
		// 写成函数模板是为了支持各种类型的迭代器
		// 若是用iterator则只支持vector的迭代器
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}
		// 构造函数还支持用n个相同的值来进行初始化
		// T()是一个匿名对象，会去调用T的构造函数
		// C++对内置类型进行了升级，也有了构造函数
		// int i = 1;
		// int j(1);
		// int k = int();
		// int x = int(1);
		vector(size_t n, const T& x = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
				push_back(x);
		}
		vector(int n, const T& x = T())
		{
			reserve(n);
			for (int i = 0; i < n; i++)
				push_back(x);
		}
		// 使用花括号的构造函数
		vector(std::initializer_list<T> il)
		{
			reserve(il.size());
			for (auto e : il)
				push_back(e);
		}
		~vector()
		{
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;
		}
		// 传统写法的拷贝构造
		/*vector(const vector<T>& v)
		{
			T* tmp = new T[v.capacity()];
			for (size_t i = 0; i < v.size(); i++)
			{
				tmp[i] = v._start[i];
			}
			_start = tmp;
			_finish = tmp + v.size();
			_end_of_storage = tmp + v.capacity();
		}*/
		// 现代写法的拷贝构造
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(v.capacity());
			for (auto e : v)
				push_back(e);
		}
		// 传统写法的赋值运算符重载
		/*vector& operator=(const vector<T>& v)
		{
			if (_start == nullptr)
				delete[] _start;
			T* tmp = new T[v.capacity()];
			for (size_t i = 0; i < v.size(); i++)
			{
				tmp[i] = v._start[i];
			}
			_start = tmp;
			_finish = tmp + v.size();
			_end_of_storage = tmp + v.capacity();
			return *this;
		}*/
		// 现代写法的赋值运算符重载
		vector& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}


		// 其他函数
		T& operator[](size_t i)
		{
			assert(i < size());
			return _start[i];
		}
		const T& operator[](size_t i) const
		{
			assert(i < size());
			return _start[i];
		}
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}
		size_t size() const
		{
			return _finish - _start;
		}
		size_t capacity() const
		{
			return _end_of_storage - _start;
		}
		void reserve(size_t n)
		{
			assert(n > capacity());
			size_t old_size = size();
			T* tmp = new T[n];
			for (int 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())
		{
			//上面给的缺省值不能给0，因为不一定是int类型，T()是针对任何类型的
			//int i = int();  ->  i=0;
			//int i = int(7)  ->  i=7;
			//C++为了让内置类型可以兼容模板
			if (n <= size())//如果比size还小或等于，不用填充，直接缩小
			{
				_finish = _start + n;
			}
			else//需要填充
			{
				if (n > capacity())//扩容
				{
					reserve(n);
				}
				//填充，从_finish的位置开始向后填充
				//填充时不能用memcpy将val直接弄到_finish到_start+n的位置
				//因为memcpy是浅拷贝,若是自定义类型且开辟了空间
				//会直接让所以的都指向同一块空间
				while (_finish < _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
		}
		void push_back(const T& x)
		{
			if (_finish == _end_of_storage)
			{
				size_t newcapacity = size() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}
		void pop_back()
		{
			assert(_finish != _end_of_storage);
			_finish--;
		}
		void insert(iterator pos, const T& x)
		{
			assert(pos <= end());
			if (_finish == _end_of_storage)
			{
				size_t newcapacity = size() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			iterator it = _finish;
			while (it >= pos)
			{
				*it = *(it - 1);
				--it;
			}
			*pos = x;
			_finish++;
		}
		iterator erase(iterator pos)
		{
			assert(pos <= end());
			if (pos == end())
				_finish--;
			else
			{
				iterator it = pos;
				while (it < end())
				{
					*it = *(it + 1);
					it++;
				}
			}
			_finish--;
			return pos;
		}
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

while(77)
关注
c++模拟算法
iyinhexidemao的博客
04-22 1157
给定两个整数A和B，输出他们的和。题目要你算A+B，你就算，这就是模拟。（2）调试时分块调试。模块化的好处就是可以方便的单独调某一部分。（1）在代码中，尽量把每个部分模块化，写成函数、结构体或类。模拟就是用计算机来模拟题目中要求的操作。（5）写代码的时候一定要思路清晰，不要想到什么写什么。
C++ STL - vector 模拟实现+解析迭代器
TPON的博客
10-12 1309
STL - vector
vactor中迭代器失效问题
Jambo!的博客
08-20 205
迭代器失效
C++— vector 的详细用法（含迭代器失效问题）
weixin_45796387的博客
04-28 1299
本章目录1. vector的介绍2. vactor的使用2.1 vector 的定义2.2 vector iterator 的使用2.3 vector 空间增长问题 1. vector的介绍 vector是表示可变大小数组的序列容器。 就像数组一样，vector 也采用连续存储空间来存储元素。也就意味着可以采用下标vector 的元素进行访问，和数组一样高效。但又不像数组，它的大小是可以以动态改变的，而且它的大小可以被容器自动处理。 本质讲，vector使用动态分配数组来存储他的元素。当新元素插入
C++算法篇 模拟算法
流年的博客
07-30 1万+
1、接水问题NOIP2010普及组 题目描述 学校里有一个水房，水房里一共装有m个龙头可供同学们打开水，每个龙头每秒钟的供水量相等，均为1。 现在有n名同学准备接水，他们的初始接水顺序已经确定。将这些同学按接水顺序从1到n编号，i号同学的接水量为wi​。接水开始时，1到m号同学各占一个水龙头，并同时打开水龙头接水。当其中某名同学jj完成其接水量要求wj​后，下一名排队等候接水的同学k马上接替j同学的位置开始接水。这个换人的过程是瞬间完成的，且没有任何水的浪费。即j同学第x秒结束时完...
⚡【C++要笑着学】(17) 模拟实现 string：深浅拷贝 | string 模拟实现 | 传统写法与现代写法
有道无术, 术尚可求。有术无道, 止于术。
05-07 4503
本章将正式介绍深浅拷贝，在模拟实现 string 的同时带着去理解深浅拷贝。我们模拟实现 string类不是为了造更好的轮子，而是为了去学习它，理解它的本质！你自己造一次，心里会更清楚，也有利于加深对 string 的理解。...
C++初阶--vector模拟实现
Iiverson2000的博客
07-29 397
今天我们不直接上代码了，我们先来分析一下vector这个容器。 我们来看看这个东西 vector<vector> 这我们可以大概猜到是一个二维数组。 但并不完全是，二维数组是一个n*n 的矩形结构，而这里的vector套vector可不是这样， 我们来剖析一下它 当我们执行 vv [ i] [ j ] 这行代码时 首先执行 vv. operator [ i ],也就是vv [ i ] 这时候我们在一个大vector中找到了，很多很多的vector。每一个vector 是用i 控制的，一
C++ STL - list 模拟实现+解析迭代器
TPON的博客
10-12 1015
STL - list iterator const_iterator reverse_iterator 模拟实现
【C++】--模拟实现vector
weixin_52563203的博客
11-24 950
vector，vector模拟实现
c++stl之 vector的底层理解及其模拟实现
qq_54626677的博客
11-26 582
示例代码// a copy of third // 下面涉及迭代器初始化的部分，我们学习完迭代器再来看这部分 // the iterator constructor can also be used to construct from arrays: int myints [ ] = {it!return 0;}
c++ dbms模拟
02-14
用c++编写的dbms原理的模拟 c++控制台模式
c++模拟软件
03-19
c++模拟软件 帮帮我 只为赚积分c++模拟软件 帮帮我 只为赚积分
关于打模拟的一些方法
C202207LYX的博客
10-27 444
摘抄自wiki index： 众所周知，模拟是十分恐怖的。 模拟题目通常具有码量大、操作多、思路繁复的特点。 由于码量大经常会出现难以查错的情况，在考试中写错是相当浪费时间。 接下来就来讲讲写模拟的技巧。 技巧： 写模拟题时，遵循以下的建议有可能会提升做题速度： 在动手写代码之前，在草纸上尽可能地写好要实现的流程。 在代码中，尽量把每个部分模块化，写成函数、结构体或类。 对于一些可能重复用到的概念，可以统一转化，方便处理：如，某题给你 “YY–MM-DD 时：分” 把它抽取到一个函数，处理成秒
C++算法 —— 模拟
最新发布
学习C++的小陈同学
04-06 1192
本篇的算法思想主要是模拟算法，实际就是按照题目要求去实现功能，主要考验代码能力和部分数学能力等等，整理了几个经典例题提供参考
C++ vector用法详解
热门推荐
wxy2020915的博客
09-08 9万+
C++ vector用法详解
c++算法基础必刷题目——模拟
weixin_52115456的博客
12-26 1512
在初赛普及组的“阅读程序写结果”的问题中，我们曾给出一个字符串展开的例子：如果在输入的字符串中，含有类似于“d-h”或“4-8”的子串，我们就把它当作一种简写，输出时，用连续递增的字母或数字串替代其中的减号，即，将上面两个子串分别输出为“defgh”和“45678”。（1）遇到下面的情况需要做字符串的展开：在输入的字符串中，出现了减号“-”，减号两侧同为小写字母或同为数字，且按照ASCII码的顺序，减号右边的字符严格大于左边的字符。3、当集合满了的时候，再次添加单词时，需要根据双端队列删除最先加入的单词。
ArrayList，LinkedList，HashMap，HashSet，vactor区别整理
wangkai3214的博客
03-03 474
ArrayList，LinkedList，HashMap，HashSet，vactor之间的区别与联系这些在面试中经常会被问到，现在整理一下，方便以后查询。 要说这些东西，就必须先提一下这些东西总体上的划分： ArrayList，LinkedList是实现了List接口，而List接口有继承了Collection接口。 vactor也是实现了List接口。 HashSet是实现了Set接口，Set...
#include <vactor>
cs785791642的博客
05-24 238
在C++中 vector是C++标准模板库中的部分内容，中文偶尔译作“容器”，但并不准确。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。 [1] [2] 简单的使用方法如下： vector<int>test;//建立...
STL vactor 的用法
Bysen32
08-29 1314
上午看了三鲜的退役报告，感触良多，ACM的最后一年了，决定学习他的方法，少看解题报告，自己想，或许到了某天我也可以发明出什么YY树之类的什么东西，最近在做线段树，里面要用到vactor动态数组，决定自己好好的学学而不是去看别人的解题报告，从这里来好好学学吧，自己一点点的摸索而不是
模拟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
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值