STL之vector模拟实现

最新推荐文章于 2024-08-08 17:20:57 发布
最新推荐文章于 2024-08-08 17:20:57 发布
阅读量264 收藏
点赞数 1
分类专栏： c++ 文章标签： STL vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Code_beeps/article/details/91411398
版权

vector的模拟实现：

注意在 Insert 和 Erase 的时候，迭代器会失效，
Insert：有可能会引发扩容，但是迭代器还指向原来的空间
Erase：删除当前位置，当前位置已经没有了，指向当前位置的迭代器也会失效
所以这两种情况都要考虑更新迭代器的指向。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
#include <string>
using namespace std;

namespace myVector{
	template<class T>
	class Vector
	{
	public:
		typedef T* Iterator;
		typedef const T* const_Iterator;

		Vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorge(nullptr)
		{}

		Vector(int n, const T& value = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorge(nullptr)
		{
			Reserve(n);
			while (n--){
				PushBack(value);
			}
		}

		//这里如果使用Iterator做迭代器，就会导致初始化的迭代器区间[first，last]只能是Vector的迭代器
		//这里重新声明迭代器，迭代器区间[first, last]可以是任意容器的迭代器区间
		template<class InputIterator>
		Vector(InputIterator first, InputIterator last)
		{
			Reserve(last - first);
			while (first != last)
			{
				PushBack(*first);
				++first;
			}
		}

		Vector(const Vector<T>& v)
		{
			//深拷贝--->开空间--->拷贝
			_start = new T[v.Capacity()];
			for (size_t i = 0; i < v.Size(); i++)
			{
				_start[i] = v[i];
			}
			_finish = _start + v.Size();
			_endOfStorge = _start + v.Capacity();
		}

		void PushBack(const T& val)
		{
			//考虑扩容
			if (_finish == _endOfStorge)
			{
				size_t newCapacity = (_start == nullptr ? 1 : 2 * Capacity());
				Reserve(newCapacity);
			}
			*_finish++ = val;
		}

		Vector<T> operator=(Vector<T> v)
		{
			Swap(v);
			return *this;
		}

		void Swap(Vector<T>& v)
		{
			//现代版
			//v是局部对象，出了作用域会释放，交换指针指向的做法
			swap(_start, v._start);
			swap(_finish, v._finish);
			swap(_endOfStorge, v._endOfStorge);
		}

		void PopBack()
		{
			Erase(end() - 1);
		}

		Iterator begin()
		{
			return _start;
		}

		Iterator end()
		{
			return _finish;
		}

		const_Iterator begin() const
		{
			return _start;
		}

		const_Iterator end() const
		{
			return _finish;
		}

		void Reserve(size_t capacity)
		{
			if (capacity > Capacity())
			{
				//三大步：1、开空间 2、深拷贝 3、更新指针
				int len = Size();
				T* newC = new T[capacity];
				if (_start)
				{
					for (int i = 0; i < len; i++)
					{
						newC[i] = _start[i];
					}
					delete[] _start;
				}
				_start = newC;
				_finish = _start + len;
				_endOfStorge = _start + capacity;
			}
		}

		void Resize(size_t n, const T& val = T())
		{
			//n 小于当前的 size，将数据个数缩小到 n
			if (n <= Size())
			{
				_finish = _start + n;
			}
			else{
				//n > 当前的容量，容量不够则增容
				if (n > Capacity())
				{
					Reserve(n);
				}
				//新增位置赋值
				while (_finish != _start + n){
					*_finish = val;
					++_finish;
				}
			}
		}

		void Insert(Iterator pos, const T& val)
		{
			assert(pos < _finish && pos >= _start);
			int len = pos - _start;

			//容量不够则扩容
			if (_finish == _endOfStorge)
			{
				size_t newC = _start == nullptr ? 1 : 2 * Capacity();
				Reserve(newC);
			}
			
			//增容之后更新迭代器
			pos = _start + len;
			Iterator end = _finish;

			//从后向前挪动元素，腾出pos的空间，放入新元素
			while (end != pos){
				*end = *(end - 1);
				--end;
			}
			*pos = val;
			_finish++;
		}

		Iterator Erase(Iterator pos)
		{
			assert(pos < _finish && pos >= _start);
			//删除pos的位置，让pos+1的位置向前依次挪动
			Iterator begin = pos + 1;
			while (begin != _finish){
				*(begin - 1) = *begin;
				begin++;
			}

			--_finish;
			return pos;
		}

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

		size_t Capacity() const
		{
			return _endOfStorge - _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];
		}

		~Vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endOfStorge = nullptr;
			}
		}
	private:
		T* _start;				//指向数据块的开始
		T* _finish;				//指向数据块的尾
		T* _endOfStorge;		//指向存储容量的尾
	};
}

template<class T>
void PrintVector(const myVector::Vector<T>& v)
{
	for (size_t i = 0; i < v.Size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}

template<class T>
void PrintVectorWithIterator(const myVector::Vector<T>& v)
{
	auto vit = v.begin();
	while (vit != v.end())
	{
		cout << *vit << " ";
		++vit;
	}
	cout << endl;
}

template<class T>
void PrintVectorWithFor(const myVector::Vector<T>& v)
{
	for (const auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

测试：

void TestVector1()
{
	myVector::Vector<int> first;	//空vector
	myVector::Vector<int> second(4, 100);	//4个int型空间，值为100
	myVector::Vector<int> third(second.begin(), second.end());	
	myVector::Vector<int> forth(third);

	int ints[] = { 2, 3, 1, 47 };
	myVector::Vector<int> fifth(ints, ints + sizeof(ints) / sizeof(ints[0]));

	PrintVectorWithIterator(first);
	PrintVectorWithIterator(second);
	PrintVectorWithIterator(third);
	PrintVectorWithIterator(forth);
	PrintVectorWithIterator(fifth);

	//测试string类型
	myVector::Vector<string> strV;
	strV.PushBack("abc");
	strV.PushBack("def");
	strV.PushBack("ghj");
	strV.PopBack();
	PrintVectorWithFor(strV);
}

void TestVector2()
{
	//使用PushBack插入4个数据
	myVector::Vector<int> v;
	v.PushBack(1);
	v.PushBack(2);
	v.PushBack(3);
	v.PushBack(4);

	//使用迭代器打印
	myVector::Vector<int>::Iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	//使用迭代器修改
	it = v.begin();
	while (it != v.end())
	{
		*it *= 2;
		++it;
	}
	PrintVectorWithIterator(v);
}

void TestVector3()
{
	size_t sz;
	myVector::Vector<int> foo;
	sz = foo.Capacity();
	cout << "making foo growing:" << endl;
	for (int i = 0; i < 100; i++)
	{
		foo.PushBack(i);
		if (sz != foo.Capacity())
		{
			sz = foo.Capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}

	//reserve
	myVector::Vector<int> bar;
	sz = bar.Capacity();
	bar.Reserve(100); // this is the only difference with foo above
	std::cout << "making bar grow:\n";
	for (int i = 0; i < 100; ++i) {
		bar.PushBack(i);
		if (sz != bar.Capacity()) {
			sz = bar.Capacity();
			std::cout << "capacity changed: " << sz << '\n';
		}
	}

	// resize
	myVector::Vector<int> myvector;
	// set some initial content:
	for (int i = 1; i < 10; i++)
		myvector.PushBack(i);
	myvector.Resize(5);
	myvector.Resize(8, 100);
	myvector.Resize(12);
	std::cout << "myvector contains:";
	for(size_t i = 0; i < myvector.Size(); i++)
		std::cout << ' ' << myvector[i];
	std::cout << '\n';
}

// find / insert / erase
void TestVector4()
{
	int a[] = { 1, 2, 3, 4 };
	myVector::Vector<int> v(a, a + sizeof(a) / sizeof(int));
	// 使用find查找3所在位置的iterator
	myVector::Vector<int>::Iterator pos = find(v.begin(), v.end(), 3);
	// 在pos位置之前插入30
	v.Insert(pos, 30);
	myVector::Vector<int>::Iterator it = v.begin();
	while (it != v.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;
	pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据
	v.Erase(pos);
	it = v.begin();
	while (it != v.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

// iterator失效问题
void TestVector5()
{
	int a[] = { 1, 2, 3, 4 };
	myVector::Vector<int> v(a, a + sizeof(a) / sizeof(int));
	// 使用find查找3所在位置的iterator
	myVector::Vector<int>::Iterator pos = find(v.begin(), v.end(), 3);
	 删除pos位置的数据，导致pos迭代器失效。
	//v.Erase(pos);
	//cout << *pos << endl; // 此处会导致非法访问
	
	 在pos位置插入数据，导致pos迭代器失效。
	 insert会导致迭代器失效，是因为insert可
	 能会导致增容，增容后pos还指向原来的空间，而原来的空间已经释放了。
	//pos = find(v.begin(), v.end(), 3);
	//v.Insert(pos, 30);
	//cout << *pos << endl; // 此处会导致非法访问
	
	// 实现删除v中的所有偶数
	// 下面的程序会崩溃掉，如果是偶数，erase导致it失效
	// 对失效的迭代器进行++it，会导致程序崩溃
	myVector::Vector<int>::Iterator it = v.begin();
	/*while (it != v.end())
	{
		if (*it % 2 == 0)
			v.Erase(it);
		++it;
	}*/
	// 以上程序要改成下面这样，erase会返回删除位置的下一个位置
	it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		it = v.Erase(it);
		else
			++it;
	}
}

int main()
{
	//TestVector1();
	//TestVector2();
	//TestVector3();
	//TestVector4();
	TestVector5();
	system("pause");
	return 0;
}
coolnut12138
关注
专栏目录
vector模拟实现
liuming
10-09 212
vector就是一个动态的顺序表，可以存放任何元素，其中使用三个指针（start，finish，end_of_storage）进行实现，本文将实现5个模块中常用的的接口。 此图大致为vector的结构。 首先声明迭代器以及维护的指针： typedef T* Itreator; private: Itreator start; Itreator finish; Itreator end_of_storage; 一、构造和析构 本文实现四种构造方法； （1）无参构造：对三个指.
C++ STL - vector 模拟实现+解析迭代器
TPON的博客
10-12 1261
STL - vector
C++STL详解（四）—— vector的模拟实现
2021dragon的博客
08-03 3020
vector的模拟实现
【C++】vector 的模拟实现
最新发布
2301_77954967的博客
08-08 1483
在 C++ 的编程世界中，vector 是一种极为常用的数据结构。理解其内部工作原理并进行模拟实现，能让我们更深入地掌握 C++ 编程的精髓。本文将带您走进 vector 模拟实现的世界，揭示其背后的神秘面纱，助您提升编程技能。迭代器的巧妙运用，通过原生指针实现简单高效的元素访问和操作。合理定义和管理私有成员变量start、finish和end_of_storage，实现对存储空间和元素范围的精确控制。构造函数涵盖了多种情况，满足不同的初始化需求。
vector的模拟实现
weixin_52540905的博客
06-19 114
构造函数 1、无参构造 2、采用迭代器的构造方法 3、拷贝构造 赋值运算符重载 析构函数 reverse（）扩容 push_back 当_finish == _endofstorage说明空间不够需要扩容。 resize（） insert erase 剩余的简单成员函数 正向迭代器 反向迭代器 方向迭代器的rbegin在正向迭代的end上，反向迭代器rend在正向迭代器的begin上。 我们为反向迭代器新建了一个类...
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
c++stl之 vector的底层理解及其模拟实现
qq_54626677的博客
11-26 534
示例代码// a copy of third // 下面涉及迭代器初始化的部分，我们学习完迭代器再来看这部分 // the iterator constructor can also be used to construct from arrays: int myints [ ] = {it!return 0;}
c++ vector模拟实现代码
08-25
本文将深入探讨`vector`的实现原理，并通过一个简单的模拟代码来展示其核心机制。 首先，`vector`是一个序列容器，它允许在任何位置插入和删除元素，同时提供了动态调整大小的能力。在内存管理上，`vector`内部使用...
C++初阶：STL之vector类模板
weixin_36194037的博客
12-14 1439
C++初阶：STL之vector类模板
【vector的模拟实现】
Willing_hope的博客
08-06 184
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
zw_ss
10-14 222
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++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、付费专栏及课程。

余额充值