模拟实现vector

最新推荐文章于 2022-09-23 11:55:58 发布
最新推荐文章于 2022-09-23 11:55:58 发布
阅读量271 收藏
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aixiaodeshushu/article/details/87921597
版权

vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。

首先，考虑一个vector类的成员变量：_start、_end、_endOfCapacity，有这三个，我们就可以知道vector的size、capacity，以及进行各种操作

	template <class T>
	class vector
	{
	public:
		typedef T* Iterator;
		typedef const T* ConstIterator;
		private:
		Iterator _start; //指向数据块的开始
		Iterator _end; //指向有效数据的末尾
		Iterator _endOfCapacity; //指向存储容量的末尾
	};

vector初始化的方法有五种

  1. vector<int> a(10);
  2. vector<int> a(10, 1);
  3. vector<int> a(b);
  4. vector<int> a(b.begin(),b.begin+3);
  5. int b[7]={1,2,3,4,5,9,8};
    vector<int> a(b,b+7);
		vector()
			:_start(nullptr)
			,_end(nullptr)
			,_endOfCapacity(nullptr)
		{}
		//对应第1, 2种
		vector(int n, const T& value = T())
			:_start(nullptr)
			, _end(nullptr)
			, _endOfCapacity(nullptr)
		{
			Reserve(n);
			while (n--)
			{
				PushBack(value);
			}
		}
		//如果使用Iterator类型的迭代器，会导致[first, end)中只用是vector类型迭代器
		//重新template一个,[first, end)就可以是任意类型的迭代器
		//对应第4， 5种
		template <class InputIterator>
		vector(InputIterator first, InputIterator end)
		{
			Reserve(end - first);
			while (first != end)
			{
				PushBack(*first);
				++first;
			}
		}
		//对应第三种
		vector(const vector<T>& v)
			:_start(nullptr)
			, _end(nullptr)
			, _endOfCapacity(nullptr)
		{
			Reserve(v.Capacity());
			Iterator it = Begin();
			ConstIterator vit = v.CBegin();
			while (vit != v.CEnd())
			{
				*it++ = *vit++;
			}
			_end = _start + v.Size();
			_endOfCapacity = _start + v.Capacity();
		}

接下来就是vector内的一些基本成员函数了：

Iterator Begin()
Iterator End() ;
ConstIterator CBegin()
ConstIterator CEnd()
Iterator RBegin()
Iterator REnd()
size_t Size()
size_t Capacity()
void Reserve();
void Resize();
void PushBack();
void PopBack();
Iterator Insert();
Iterator Erase();
T& operator; //为了通过下标访问

最后，就是测试代码，测试代码一定要全方面，我的测试代码可能不太全面，还望指正

附代码

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

namespace LHZ
{
	template <class T>
	class vector
	{
	public:
		typedef T* Iterator;
		typedef const T* ConstIterator;
		vector()
			:_start(nullptr)
			,_end(nullptr)
			,_endOfCapacity(nullptr)
		{}
		vector(int n, const T& value = T())
			:_start(nullptr)
			, _end(nullptr)
			, _endOfCapacity(nullptr)
		{
			Reserve(n);
			while (n--)
			{
				PushBack(value);
			}
		}
		//如果使用Iterator类型的迭代器，会导致[first, end)中只用是vector类型迭代器
		//重新template一个,[first, end)就可以是任意类型的迭代器
		template <class InputIterator>
		vector(InputIterator first, InputIterator end)
		{
			Reserve(end - first);
			while (first != end)
			{
				PushBack(*first);
				++first;
			}
		}

		vector(const vector<T>& v)
			:_start(nullptr)
			, _end(nullptr)
			, _endOfCapacity(nullptr)
		{
			Reserve(v.Capacity());
			Iterator it = Begin();
			ConstIterator vit = v.CBegin();
			while (vit != v.CEnd())
			{
				*it++ = *vit++;
			}
			_end = _start + v.Size();
			_endOfCapacity = _start + v.Capacity();
		}

		~vector()
		{
			delete[] _start;
			_start = _end = _endOfCapacity = nullptr;
		}

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

		void Swap(vector<T>& v)
		{
			swap(_start, v._start);
			swap(_end, v._end);
			swap(_endOfCapacity, v._endOfCapacity);
		}

		Iterator Begin() { return _start; }
		Iterator End() { return _end; }
		ConstIterator CBegin() const{ return _start; }
		ConstIterator CEnd() const { return _end; }
		Iterator RBegin() { return _end; }
		Iterator REnd() { return _start; }

		size_t Size() const { return _end - _start; }
		size_t Capacity() const { return _endOfCapacity - _start; }

		void Reserve(size_t n)
		{
			if (n > Capacity())
			{
				size_t size = Size();
				T* tmp = new T[n];
				for (size_t i = 0; i < size; ++i)
				{
					tmp[i] = _start[i];
				}
				_start = tmp;
				_end = _start + size;
				_endOfCapacity = _start + n;
			}
		}
		void Resize(size_t n, const T& value = T())
		{
			if (n < Size())
			{
				_end = _start + n;
				return;
			}
			if (n > Capacity())
			{
				Reserve(n);
			}
			Iterator it = _end;
			_end = _start + n + 1;
			while (it != _end)
			{
				*it = value;
				++it;
			}
		}

		void PushBack(const T& value)
		{
			Insert(End(), value);
		}
		void PopBack()
		{
			Erase(End() - 1);
		}

		Iterator Insert(Iterator pos, const T& value)
		{
			assert(pos <= _end);
			if (_end == _endOfCapacity)
			{
				size_t size = Size();
				size_t newCapacity = 0;
				newCapacity = Capacity() == 0 ? 1 : Capacity() * 2;
				Reserve(newCapacity);
				pos = _start + Size();
			}
			Iterator end = _end - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = value;
			_end++;
			return pos;
		}

		Iterator Erase(Iterator pos)
		{
			Iterator begin = pos + 1;
			while (begin != _end)
			{
				*(begin - 1) = *(begin);
				++begin;
			}
			--_end;
			return pos;
		}

		T& operator[](size_t i)
		{
			return _start[i];
		}

	private:
		Iterator _start; //指向数据块的开始
		Iterator _end; //指向有效数据的末尾
		Iterator _endOfCapacity; //指向存储容量的末尾
	};
}

//测试代码
//test1用于测试vector的初始化
void test1()
{
	LHZ::vector<int> first;
	LHZ::vector<int> second(4, 100);
	LHZ::vector<int> third(second.Begin(), second.End());
	LHZ::vector<int> fourth(third);

	int arr[] = { 1, 2, 3, 4 };
	LHZ::vector<int> fifth(arr, arr + sizeof(arr) / sizeof(arr[0]));
	for (LHZ::vector<int>::Iterator it = fifth.Begin(); it != fifth.End(); ++it)
	{
		cout << *it << ' ';
	}

	//测试字符串
	LHZ::vector<string> strV;
	strV.PushBack("hahhaha");
	strV.PushBack("nihao");
	strV.PushBack("nishizhuma");
	for (size_t i = 0; i < strV.Size(); ++i)
	{
		cout << strV[i] << " ";
	}
	cout << endl;
}

//打印函数
void Print(const LHZ::vector<int>& v)
{
	for (LHZ::vector<int>::ConstIterator it = v.CBegin(); it != v.CEnd(); ++it)
	{
		cout << *it << ' ';
	}
	cout << endl;
}

//测试：插入/删除/修改数据
void test2()
{
	LHZ::vector<int> v;
	for (size_t i = 0; i < 5; ++i)
	{
		v.PushBack(i);
	}
	Print(v);
	v.PopBack();
	Print(v);
	v.Insert(find(v.Begin(), v.End(), 3), 8);
	Print(v);
	v.Erase(find(v.Begin(), v.End(), 3));
	Print(v);
}

//测试：reserve/resize
void test3()
{
	//扩容问题
	LHZ::vector<int> v1;
	/*size_t sz = v1.Capacity();
	for (size_t i = 0; i < 100; ++i)
	{
		v1.PushBack(i);
		if (sz != v1.Capacity())
		{
			sz = v1.Capacity();
			cout << sz << " ";
		}
	}*/

	//刚开始就reserve(),看是否扩容
	LHZ::vector<int> v2;

	v2.Reserve(100);
	size_t sz = v2.Capacity();
	for (size_t i = 0; i < 100; ++i)
	{
		v2.PushBack(i);
		if (sz != v2.Capacity())
		{
			sz = v2.Capacity();
			cout << sz << " ";
		}
	}

	//resize
	LHZ::vector<int> v3;
	for (size_t i = 0; i < 10; ++i)
	{
		v3.PushBack(i);
	}
//	v3.Resize(5);
	Print(v3);

	v3.Resize(15, 10);
	Print(v3);
}

//operator[]
void test4()
{
	LHZ::vector<int> v;
	for (size_t i = 0; i < 5; ++i)
	{
		v.PushBack(i);
	}
	cout << v[3] << endl;
}

int main()
{
	test1();
	system("pause");
	return 0;
}
The Laughing Uncle
关注
专栏目录
C++模拟实现vector
03-07
C++模拟实现vector
vector 模拟实现
03-20
对vector 的实现的模拟。使用《c++ primar》 中的部分代码，并进行了完善。
C++STL详解（四）—— vector的模拟实现
2021dragon的博客
08-03 3198
vector的模拟实现
vector模拟实现
m0_60447315的博客
09-23 1375
💖 作者简介：大家好，我是菀枯😜💬格言：不要在低谷沉沦自己，不要在高峰上放弃努力！☀️大家在学习C++的时候一定会学到STL（标准模板库），这是C++标准库中最重要的组成部分，它包含了常用的数据结构和算法。今天呢，我们首先来学习STL中的vector容器vector的数据安排和操作方式与我们平时使用的数组非常相似，唯一的区别在于数组是一个固定空间，而vector的空间可以随着元素的改变而发生改变。还是和之前一样，vector的使用方式大家可以去查阅官方文档欢迎各位参考与指导！！！
模拟实现Vector
zw_ss
10-14 246
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...
vector的简单模拟
Enthusiastic_boy的博客
04-13 947
目录 构造与析构 简单方法的模拟 拷贝构造与赋值运算符重载 浅拷贝问题 深拷贝 扩容 reserve() resize() 插入与删除 push_back() insert() erase() 构造与析构 模拟实现时，依然使用vector作为容器的名字，为了防止与std命名空间中的vector冲突，使用自定义的命名空间，将模拟实现的类放入即可。vecotr容器中可以存储多种类型的值，所以需要使用模板的方式。类的实现方法也有多种，以下实现采用三指针的方式，比如容器中的有效元素.
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
简单模拟vector的实现
Hlun的博客
10-17 470
运用类型萃取，模拟string，简单模拟vector。。。。
vector的模拟实现
晶凌玄夜的博客
04-19 194
vector是表示可变大小数组的序列容器。 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小。为了增加存储空间，其做法是，分配一个新的数组，然后将全...
【STL】之Vector的模拟实现
f2016913的博客
03-07 830
一：迭代器失效？ 前面我们了解迭代器其实就是智能指针，可以通过运算符的操作来实现接口函数，但有时有会存在安全隐患。这就是我们常说的迭代器失效。所谓的迭代器失效其实是找某个位置的元素，删除，然后再通过operator++，operator--访问下一个元素，会出现野指针造成崩溃的问题； 如下： #include #include using namespace std; void Test
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值