C++ STL之vector容器的模拟实现

最新推荐文章于 2024-06-16 21:44:51 发布
最新推荐文章于 2024-06-16 21:44:51 发布
阅读量196 收藏
点赞数
分类专栏： C++练习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq947467490/article/details/130441395
版权

目录

一、模拟实现的思路

二、逐步模拟实现

1.成员变量的设置

2.迭代器的相关函数

3.构造函数

4.赋值操作

5.容量与大小

6.数据存取

7.互换容器

8.插入与删除

三、总结

一、模拟实现的思路

【大概思路】

利用_start和_finish来确定vector的位置和所存入数据数目，利用_capacity来确定vector的整体容量大小。后续再进行相关函数功能的实现。

二、逐步模拟实现

1.成员变量的设置

namespace imitate
{
	template<class T>
	class vector
	{
	public:
		typedef T* const_iterator;
		typedef T* iterator;
    public:
        // ... 后续的成员函数

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

2.迭代器的相关函数

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

3.构造函数

【注意】

memcpy，strcpy第一次拷贝的时候不能给空,memcpy不能使用进行对象之间的拷贝，是按字节拷贝的浅拷贝。

		vector()
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}
		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];
			_finish = _start;
			_endofstorage = _start + v.capacity();

			//memcpy(tmp, _start, sizeof(T)*size());   
			//memcpy，strcpy第一次拷贝的时候不能给空
            //memcpy 不能使用进行对象之间的拷贝，是按字节拷贝的浅拷贝

			for (int i = 0; i < v.size(); ++i)
			{
				*_finish = v[i];
				_finish++;
			}
		}
		vector(iterator begin, iterator end)
		{
			size_t n = end - begin;
			_start = new T[n];
			_endofstorage = _start + n;
			_finish = _start;
			for (int i = 0; i < n; ++i)
			{
				*_finish = begin[i];
				++_finish;
			}
		}
		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

 

4.赋值操作

		vector<T>& operator=(vector<T>& v)
		{
			if (this != &v)
			{
				vector<T> tmp(v);
				swap(tmp);
			}
			return *this;
		}


		void assign(iterator begin, iterator end)
		{
			vector<T> tmp(begin, end);
			swap(tmp);
		}
		void assign(size_t n, const T& x)
		{
			if(!_start) delete[] _start;
			iterator tmp = new T[n];
			for (size_t i = 0; i < n; ++i)	tmp[i] = x;
			_start = tmp;
			_finish = _start + n;
			_endofstorage = _start + n;
		}

5.容量与大小

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

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

		void reserve(size_t n)
		{
			if (n <= capacity()) return;
			size_t len = size();
			iterator tmp = new T[n];
			if (_start)
			{
				for (size_t i = 0; i < len; ++i)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
			}
			_start = tmp;
			_finish = tmp + len;
			_endofstorage = tmp + n;
		}

		void resize(size_t n, const T& elem = T())
		{
			if (n <= size())
			{
				_finish = _start + n;
				return;
			}
			if (n >= capacity())
			{
				reserve(n);
			}
			iterator it = _finish;
			_finish += n;
			while (it != _finish)
			{
				*it = elem;
				it++;
			}
		}

6.数据存取

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

7.互换容器

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

8.插入与删除

注意插入与删除会改变原有迭代器指向的位置，需要及时更新迭代器。

		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}

		void pop_back()
		{
			assert(_start < _finish);
			_finish--;
		}

		iterator insert(iterator pos, const T& x)
		{
			assert(pos < _finish);
			if (_finish == _endofstorage)
			{
				size_t n = pos - _start; // 防止迭代器失效，先储存元素个数
				size_t newcapacity = (capacity() == 0) ? 2 : capacity() * 2;

				reserve(newcapacity);
				pos = _start + n; // 防止迭代器失效，即使更新pos的地址
			}
			iterator end = _finish;
			while (end > pos)
			{
				*end = *(end - 1);
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}
		void insert(iterator pos, size_t n, const T& x)
		{
			assert(pos < _finish);
			if (_endofstorage - _finish < n)
			{
				size_t n = pos - _start;
				size_t newcapacity = (capacity() == 0) ? n : size() + n;
				reserve(newcapacity);
				pos = _start + n;
			}
			iterator it1 = _finish + n;
			while (it1 < pos + n)
			{
				*it1 = *(it1 - 1);
				it1--;
			}
			for (iterator it2 = pos; it2 != pos + n; ++it2)
			{
				*it2 = x;
			}
			_finish += n;
		}

		iterator erase(const_iterator pos)
		{
			assert(pos < _finish);
			iterator it = pos;
			while (it < _finish)
			{
				*it = *(it + 1);
				it++;
			}
			_finish--;
			return pos;
		}
		iterator erase(iterator begin, iterator end)
		{
			assert(begin < _finish && end <= _finish);
			size_t n = end - begin;
			iterator it = begin;
			while (it + n < _finish)
			{
				*it = *(it + n);
				it++;
			}
			_finish -= n;
			return begin;
		}

三、总结

MyVector.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS

#include<iostream>
#include<assert.h>

namespace imitate
{
	template<class T>
	class vector
	{
	public:
		typedef T* const_iterator;
		typedef T* iterator;
	public:
		vector()
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}
		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];
			_finish = _start;
			_endofstorage = _start + v.capacity();

			//memcpy(tmp, _start, sizeof(T)*size());   
			//memcpy，strcpy第一次拷贝的时候不能给空,memcpy不能使用进行对象之间的拷贝，是按字节拷贝的浅拷贝

			for (int i = 0; i < v.size(); ++i)
			{
				*_finish = v[i];
				_finish++;
			}
		}
		vector(iterator begin, iterator end)
		{
			size_t n = end - begin;
			_start = new T[n];
			_endofstorage = _start + n;
			_finish = _start;
			for (int i = 0; i < n; ++i)
			{
				*_finish = begin[i];
				++_finish;
			}
		}
		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}


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

		void reserve(size_t n)
		{
			if (n <= capacity()) return;
			size_t len = size();
			iterator tmp = new T[n];
			if (_start)
			{
				for (size_t i = 0; i < len; ++i)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
			}
			_start = tmp;
			_finish = tmp + len;
			_endofstorage = tmp + n;
		}

		void resize(size_t n, const T& elem = T())
		{
			if (n <= size())
			{
				_finish = _start + n;
				return;
			}
			if (n >= capacity())
			{
				reserve(n);
			}
			iterator it = _finish;
			_finish += n;
			while (it != _finish)
			{
				*it = elem;
				it++;
			}
		}

		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}

		void pop_back()
		{
			assert(_start < _finish);
			_finish--;
		}

		iterator insert(iterator pos, const T& x)
		{
			assert(pos < _finish);
			if (_finish == _endofstorage)
			{
				size_t n = pos - _start; // 防止迭代器失效，先储存元素个数
				size_t newcapacity = (capacity() == 0) ? 2 : capacity() * 2;

				reserve(newcapacity);
				pos = _start + n; // 防止迭代器失效，即使更新pos的地址
			}
			iterator end = _finish;
			while (end > pos)
			{
				*end = *(end - 1);
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}
		void insert(iterator pos, size_t n, const T& x)
		{
			assert(pos < _finish);
			if (_endofstorage - _finish < n)
			{
				size_t n = pos - _start;
				size_t newcapacity = (capacity() == 0) ? n : size() + n;
				reserve(newcapacity);
				pos = _start + n;
			}
			iterator it1 = _finish + n;
			while (it1 < pos + n)
			{
				*it1 = *(it1 - 1);
				it1--;
			}
			for (iterator it2 = pos; it2 != pos + n; ++it2)
			{
				*it2 = x;
			}
			_finish += n;
		}

		iterator erase(const_iterator pos)
		{
			assert(pos < _finish);
			iterator it = pos;
			while (it < _finish)
			{
				*it = *(it + 1);
				it++;
			}
			_finish--;
			return pos;
		}
		iterator erase(iterator begin, iterator end)
		{
			assert(begin < _finish && end <= _finish);
			size_t n = end - begin;
			iterator it = begin;
			while (it + n < _finish)
			{
				*it = *(it + n);
				it++;
			}
			_finish -= n;
			return begin;
		}

		vector<T>& operator=(vector<T>& v)
		{
			if (this != &v)
			{
				vector<T> tmp(v);
				swap(tmp);
			}
			return *this;
		}

		void assign(iterator begin, iterator end)
		{
			vector<T> tmp(begin, end);
			swap(tmp);
		}
		void assign(size_t n, const T& x)
		{
			if(!_start) delete[] _start;
			iterator tmp = new T[n];
			for (size_t i = 0; i < n; ++i)	tmp[i] = x;
			_start = tmp;
			_finish = _start + n;
			_endofstorage = _start + n;
		}

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

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

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

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


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

功德箱我每年都投
关注
专栏目录
c++ vector模拟实现代码
08-25
在C++标准模板库(STL)中，`vector`是一个非常关键的容器，它提供了类似于动态数组的功能。本文将深入探讨`vector`的实现原理，并通过一个简单的模拟代码来展示其核心机制。 首先，`vector`是一个序列容器，它允许在...
【C++STL】模拟实现vector容器
邓富民的博客
07-16 2569
C++STL的vector容器常用接口的模拟实现
C++类——Vector容器的模拟实现
weixin_69283129的博客
07-26 1024
C++类Vector的模拟实现
vector容器
qq_51691366的博客
04-12 695
vector 和 arry 非常相似，唯一存在的不同是 vector 是动态分配内存空间，但是 arry 是静态的。
vector的使用和实现
m0_72532428的博客
06-03 959
vector常用接口的使用与模拟实现
C++ 迭代器(iterator)超详解+实例演练
热门推荐
qq_52324409的博客
11-13 6万+
C++ STL 迭代器详解一级目录二级目录三级目录 一级目录 二级目录 三级目录
深入解析C++ STL中的常用容器
09-05
本篇文章将深入解析C++ STL中的一些常用容器，包括顺序性容器、关联容器以及容器适配器。 1. 顺序性容器 - (1) vector `vector` 是一种动态数组，内存中存储是连续的，支持快速随机访问。但由于插入和删除操作...
C++开源项目：模拟实现小型STL
11-27
本开源项目旨在模拟实现一个小型STL，帮助开发者更深入地理解STL的工作原理和设计思想。下面我们将详细探讨其中涉及的知识点。 1. **容器**：STL中的容器是用来存储数据的对象，如`vector`、`deque`、`list`、`set`...
C++的Vector实现.zip
08-20
在C++编程中，STL（Standard Template Library，标准模板库）是一个强大的工具集，它包含了许多容器类，如vector、list、set等。其中，`std::vector`是一个动态数组，提供了方便的序列容器功能，允许高效地进行元素...
第七章：vector类
m0_63027727的博客
03-20 1036
第七章：vector类 1.vector的介绍 vector的文档 ①vector是表示可变大小数组的序列容器。 ②就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。 ③本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相
C++编程：vector容器的简单模拟实现
最新发布
htw250056的博客
06-16 1029
在C++标准库（STL）中，vector容器是最常见使用的动态数组。它结合了链表与数组的优点，提供了灵活的大小调整与高效的随机访问。本文将简单的对vector容器进行介绍并且对vector容器简单的模拟实现。1. vector是表示可变大小数组的序列容器。2.就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。3.本质讲，vector。
C++ 迭代器 iterator 详解
WWester的博客
09-02 2149
迭代器 功能：访问容器对象的元素。所有标准库容器都可以使用迭代器，其中只有少数几种才同时支持下标运算符。严格来说，string对象不属于容器类型，但是string支持很多与容器类型类似的操作。迭代器分为有效和无效，类似于指针。有效的迭代器：指向某个元素，或者指向容器中尾元素的下一个位置；无效的迭代器：除上述的其他所有情况。
【数据结构】（一）表（List）与其在C++中的实现与迭代器iterator
超级超级小天才的博客
08-08 833
抽象数据类型（abstract data type，ADT）是带有一组操作的一些对象的集合。An abstract data type (ADT) is a set of objects together with a set of operations. 标准模板库（Standard Template Library，SLT）。实现了ADT等数据结构，这些数据结构被称为集合（collect...
iterator迭代器 || begin（）、end（）返回值类型
Jeff_的博客
11-25 1万+
迭代器是广义上的指针，事实上，它可以是指针，也可以是一个对其执行类似指针的操作——如解除引用（如operator*（））和递增（如operator++（）） ——的对象。 通过将指针广义化为迭代器，让STL能够为各种不同的容器类（包括哪些简单指针无法处理的类）提供统一的接口。每个容器类都定义了一个合适的迭代器，该迭代器的类型是一个名为iterator的typedef，其作用域为整个类。 #i...
迭代器iterator
ccnnli的博客
05-06 292
迭代器成员：begin和end； 其中begin成员负责返回指向第一个元素的迭代器；end成员负责返回指向容器的“尾元素的下一位置”，也就是说指示的是一个本不存在的“尾后”元素，end成员返回的迭代器被称作尾后迭代器； 如果容器为空，begin和end返回的是同一个迭代器，都是尾后迭代器； 所有标准库容器的迭代器大多数都没有定义 只要两个迭代器指向的是同一个容器中的元素或者尾元素的下一
07 | 迭代器和好用的新for循环
qq_37756660的博客
10-09 280
迭代器是一个很通用的概念，并不是一个特定的类型。它实际上是一组对类型的要求。它的最基本要求就是从一个端点出发，下一步、下一步地到达另一个端点。按照一般的中文习惯，也许“遍历”是比“迭代”更好的用词。我们可以遍历一个字符串的字符，遍历一个文件的内容，遍历目录里的所有文件，等等。这些都可以用迭代器来表达。我在用 output_container.h 输出容器内容的时候，实际上就对容器的 begin 和 end 成员函数返回的对象类型提出了要求。
Iterator学习
zhong29的博客
02-06 197
参考：https://blog.csdn.net/summerxiachen/article/details/59538640 https://blog.csdn.net/gogokongyin/article/details/51206225 什么是Iterator?     迭代器本质来说是一个对象，在使用iterator()方法后返回一个Iterator对象，Iterator实际上是一...
C++ vector迭代器iterator 和 erase() 如果这些细节你都知道,你一定是一个认真的人
kikyou132的博客
05-24 1469
迭代器的操作 关于erase(iter)的返回值问题 erase(iter1,iter2)具体删除哪些
C++ Vector常用函数
如意娘的博客
12-06 5134
C++ Vector常用函数 begin()函数 原型： iterator begin();             const_iterator begin(); 功能：返回一个当前vector容器中起始元素的迭代器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值