vector的模拟实现

最新推荐文章于 2024-07-03 16:17:13 发布
最新推荐文章于 2024-07-03 16:17:13 发布
阅读量599 收藏 5
点赞数 5
分类专栏： C++ 文章标签： 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zdlynj/article/details/131861570
版权

目录

一、vector类

二、构造函数及析构函数

1、构造函数

2、析构函数

三、vector的迭代器

四、vector空间增长问题

1、size

2、capacity

3、empty

4、resize

5、reserve

五、vector的增删查改

1、push_back

2、pop_back

六、其他构造函数

1、拷贝构造函数

2、构造并初始化

3、迭代器进行初始化构造

七、运算符重载

1、下标访问  [ ]

2、赋值构造

八、迭代器失效问题（重难点）

1、insert

2、erase

九、总代码

一、vector类

1、 vector是表示可变大小数组的序列容器。
2、 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3、 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4、 vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。

上面的图片来自于《STL源码剖析》这本书。从图中我们就可以看出vector实现的基本形式。vector类的成员变量是三个指针。指向起始位置的 _start ，指向最后一个数据的下一个位置的_finish，指向容量的下一个位置的_end_of_storage。

下面的代码就是vector类实现的基本框架

template<class T>
class vector
{
    typedef T* iterator;
	typedef const T* const_iterator;

private:
//三者均为指针
    iterator _start;
	iterator _finish;//最后一个数据的下一个位置
	iterator _end_of_storage;//容量的下一个位置
};

二、构造函数及析构函数

1、构造函数

将三个指针全都置成空。

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

2、析构函数

delete掉 _start的空间，将三者置成nullptr。

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

三、vector的迭代器

vector的迭代器是一个指针。并分为 iterator 和 const_iterator两种类型，非const 对象调用前者，const对象调用后者。

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、size

获取数据个数 
size_t size()const
{
	return _finish - _start;
}

2、capacity

获取容量大小 
size_t capacity()const
{
	return _end_of_storage - _start;
}

3、empty

判断是否为空 
bool empty()const
{
	return size() == 0;
}

4、resize

void resize(size_t n, const T& val = T())
{
	if (n > capacity())
	{
		reserve(n);
	}

	if (n > size())
	{
		while (_finish < _start + n)
		{
			*_finish = val;
			_finish++;
		}
	}
	else
	{
		_finish = _start + n;
    }
}

5、reserve

void reserve(size_t n)
{
	size_t sz = size();
	if (n > capacity())
	{
		T* tmp = new T[n];
		if (_start)
		{
					//memcpy(tmp, _start, sizeof(T) * sz);
					//如果是vector<vector<int>>类型，那么在拷贝
					//vector中的vector<int>的数据类型时使用memcpy是浅拷贝
					//会被析构两次
			for (size_t i = 0; i < sz; i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}
		_start = tmp;
		_finish = _start + sz;
		_end_of_storage = _start + n;
	}
}

五、vector的增删查改

1、push_back

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

2、pop_back

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

六、其他构造函数

1、拷贝构造函数

//拷贝构造函数 v2(v1)
vector(const vector<T>& v)
{
	_start = new T[v.size()];
	memcpy(_start, v._start, sizeof(T) * v.size());
			
	_finish = _start + v.size();
	_end_of_storage = _start + v.size();
}
vector(const vector<T>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _end_of_storage(nullptr)
{
	reserve(v.size());
	for (const auto& e : v)
	{
		push_back(e);
	}
}

注：上面的第一种写法其实还有一点bug。举个例子：如果vector里的数据类型是 vector<int>，那么在这memcpy就是一个浅拷贝，虽然vector<vector<int>>有自己的空间，但是里面的数据vector<int>却没有自己的空间，memcpy后，两个对象的vector<int>会指向同一块空间。因此有下面的改进方案

vector(const vector<T>& v)
{
	_start = new T[v.size()];
	for (size_t i = 0; i < v.size(); i++)
	{
		_start[i] = v._start[i];
	}
	_finish = _start + v.size();
	_end_of_storage = _start + v.size();
}

2、构造并初始化

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

3、迭代器进行初始化构造 

template<class InputIterator>
vector(InputIterator first, InputIterator last)
	:_start(nullptr)
	, _finish(nullptr)
	, _end_of_storage(nullptr)
{
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}

有了迭代器的区间构造，我们就可以写出拷贝构造函数的现代写法

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)
	:_start(nullptr)
	, _finish(nullptr)
	, _end_of_storage(nullptr)
{
	vector<T> tmp(v.begin(), v.end());
	swap(tmp);
}
​

七、运算符重载

1、下标访问  [ ]

T& operator[](size_t pos)
{
	assert(pos < size());
	return _start[pos];
}
const T& operator[](size_t pos)const
{
	assert(pos < size());
	return _start[pos];
}

2、赋值构造

//v1 = v2
vector<T>& operator=(vector<T> v)
{
	swap(v);
	return *this;
}

八、迭代器失效问题（重难点）

1、insert

void insert(iterator pos, const T& x)//返回新插入位置的迭代器 pos
{
	assert(pos >= _start);
	assert(pos <= _finish);
	//满了就扩容:扩容后pos的原位置失效，需要更新pos的位置，
	if (_finish == _end_of_storage)
	{
		reserve(capacity() == 0 ? 4 : capacity() * 2);
	}
	iterator end = _finish - 1;
	while (pos <= end)
	{
		*(end + 1) = *end;
		end--;
	}
	*pos = x;
	_finish++;
}

 

从上面的图中我们可以看出程序出现了错误，这是为什么呢？这是因为我们在第一次扩容时开辟了4个数据的空间，然后插入了4个数据。这时如果我们再插入数据 ，那么就会发生扩容，也就是会重新开辟空间，而重新开辟空间后pos的位置就没有指向新空间的pos的位置了，pos成为了一个野指针。因此迭代器就失效了。为了解决这个问题，我们就需要重新找到pos的位置，并返回这个位置。

iterator insert(iterator pos, const T& x)//返回新插入位置的迭代器 pos
{
	assert(pos >= _start);
	assert(pos <= _finish);
	//满了就扩容:扩容后pos的原位置失效，需要更新pos的位置，
	if (_finish == _end_of_storage)
	{
		size_t len = pos - _start;
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		pos = _start + len;
	}
	iterator end = _finish - 1;
	while (pos <= end)
	{
		*(end + 1) = *end;
		end--;
	}
	*pos = x;
	_finish++;
	return pos;
}

2、erase

void erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
	iterator begin = pos + 1;
	while (begin < _finish)
	{
		*(begin - 1) = *begin;
		begin++;
	}
	_finish--;
}

erase也有失效的情况。

void test()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    
    //删除所有偶数
    auto it = v.begin();
    while(it != v.end())
    {
        if(*it % 2 == 0)
        {
            v.erase(*it);
        }
        it++;
    }

    for(auto e : v)
    {
        cout << e << " ";
    }
}

push_back下面的数及对应结果。 

1        2        3        4        5             正常运行

1        2        3        4                        崩溃

1        2        4        3        4        5        结果不对

为什么会这样呢？看下图

 

第二种情况是it和end()已经错过了，且it已经越界了，永远不会相等了。 

所以正确的代码如下：

//指向擦除的最后一个元素之后的元素的新位置。pos
iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
	iterator begin = pos + 1;
	while (begin < _finish)
	{
		*(begin - 1) = *begin;
		begin++;
	}
	_finish--;
	return pos;
}
void test()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    
    //删除所有偶数
    auto it = v.begin();
    while(it != v.end())
    {
        if(*it % 2 == 0)
        {
            it = v.erase(*it);
        }
        else
        {
            it++;
        }
    }

    for(auto e : v)
    {
        cout << e << " ";
    }
}

九、总代码

using namespace std;

namespace zdl
{
	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)
		{}

		//拷贝构造函数 v2(v1)
		vector(const vector<T>& v)
		{
			_start = new T[v.size()];
			//memcpy(_start, v._start, sizeof(T) * v.size());
			/*如果是vector<vector<int>>类型，那么在拷贝
		    vector中的vector<int>的数据类型时使用memcpy是浅拷贝
			会被析构两次*/
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v._start[i];
			}
			_finish = _start + v.size();
			_end_of_storage = _start + v.size();
		}
		/*vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(v.size());
			for (const auto& e : v)
			{
				push_back(e);
			}
		}*/

		//现代写法
		/*vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}*/

		//eg : 10个1构造
		vector(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		vector(int n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		//迭代器区间构造
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}

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

		//v1 = v2
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

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

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

		size_t capacity()const
		{
			return _end_of_storage - _start;
		}
	
		void reserve(size_t n)
		{
			size_t sz = size();
			if (n > capacity())
			{
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);
					//如果是vector<vector<int>>类型，那么在拷贝
					//vector中的vector<int>的数据类型时使用memcpy是浅拷贝
					//会被析构两次
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

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

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

		iterator insert(iterator pos, const T& x)//返回新插入位置的迭代器 pos
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			//满了就扩容:扩容后pos的原位置失效，需要更新pos的位置，
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = _start + len;
			}
			iterator end = _finish - 1;
			while (pos <= end)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}

		//指向擦除的最后一个元素之后的元素的新位置。pos
		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			iterator begin = pos + 1;
			while (begin < _finish)
			{
				*(begin - 1) = *begin;
				begin++;
			}
			_finish--;
			return pos;
		}

		T& operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];
		}


		const T& operator[](size_t pos)const
		{
			assert(pos < size());
			return _start[pos];
		}

		void resize(size_t n, const T& val = T())
		{
			if (n > capacity())
			{
				reserve(n);
			}

			if (n > size())
			{
				while (_finish < _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

	private:
		//三者均为指针
		iterator _start;
		iterator _finish;//最后一个数据的下一个位置
		iterator _end_of_storage;//容量的下一个位置
	};
}

dbln
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
【C++详解】——vector模拟实现
weixin_69519040的博客
11-23 681
本文首先简单介绍了vector，随后模拟实现了vector。 解决了模拟实现过程中，reserve扩容时导致的问题，insert和erase过程中迭代器失效问题，构造函数复用迭代器构造以及构造n个val值时出现的问题，拷贝构造函数中对于自定义类型的处理。
c++ vector模拟实现代码
08-25
下面是一个简化的`vector`模拟实现： ```cpp template class vector { public: typedef T* iterator; // 构造函数 vector() : start(nullptr), finish(nullptr), end_of_storage(nullptr) {} vector(size_t n,...
vector模拟实现
wmh
06-12 2838
vector的模拟实现
【C++】vector模拟实现
VHhhbb的博客
07-15 953
【C++】vector模拟实现
C++ vector模拟实现
Wzs040810的博客
01-10 3610
C++ STL vector模拟实现
Vector模拟实现
2301_77272486的博客
04-27 861
模拟实现Vector容器，深入了解Vector的底层运行原理
[C++]vector模拟实现
weixin_52345097的博客
03-05 1123
C++vector模拟实现
C++ [STL之vector模拟实现]
ARMCSKGT的博客
05-27 5234
vector是STL容器容器之一，其底层实现类似于数据结构顺序表，相当于string来说得益于泛型模板的加持使得vector可以变为任何类型，且是可以动态扩容，堪称大号数组！在vector的实现中，有许多值得我们学习的细节，接下来将为大家一 一介绍！
【C++】vector 模拟实现
m0_51064412的博客
08-05 1380
文章目录一.vector介绍二. vector的模拟实现1. private成员变量及迭代器2. 容量操作接口2.1 size和capacity2.2 reserve2.2 resize3. 默认成员函数3.1 构造函数3.2 拷贝构造3.3 赋值重载4. 修改操作接口4.1 insert4.2 erase 一.vector介绍 vector是表示可变大小数组的序列容器 就像数组一样，vector也采用连续的存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不
C++入门之vector的模拟实现
cls的博客
03-26 1104
vector源代码的大致框架,vector本质就是一个模板类 vector的成员变量不再是我们熟悉的size，capacity，而是变成了功能一致的三个指针 namespace pxl { template<class T> class vector { public: typedef T* iterator; private: iterator _start; iterator _finish; iterator _endofstora.
【C++】STL——vector模拟实现
M的博客
06-20 1365
vector的模拟实现
vector 模拟实现
03-20
在本模拟实现中，我们将探讨如何根据《C++ Primer》一书中的指导，创建一个基本的`vector`类，关注其核心功能，如内存管理、动态增长和STL（标准模板库）接口的兼容性。以下是对这个模拟实现的一些关键知识点的详细...
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
C++模拟实现vector
03-07
C++模拟实现vector
新型开发语言的试用感受-仓颉语言发布之际
opendba的专栏
07-03 2832
Zig、Odin、Mojo、codon、carbon、nim等语言的使用感受
飞机大战系列 Space War1.0（免费，开源）
07-14
飞机大战系列 Space War1.0（免费，开源）
基于Hadoop的文件词频统计的实现（大数据技术课程设计）
07-14
使用Hadoop大数据架构体系中的HDFS、HBase以及Spark软件，完成大数据处理的典型案例：文件词频统计的实现。
湖科大计算机网络视频笔记，跟着视频系统学了一遍的记录
最新发布
07-14
视频链接：https://www.bilibili.com/video/BV1c4411d7jb/，适用于考研后期查缺补漏和前期确定复习方向、期末考和课前预习。做成PDF形式便于查阅和在iPad上查看。
matlab下载，表面张力，main.m
07-14
matlab下载，表面张力，main.m
c++模拟实现vector
09-01
引用和提供了关于实现vector的两种方法。其中，引用展示了一个使用reserve和push_back方法的示例，而引用展示了一个使用new和memcpy函数的示例。这两种方法都是常见的实现vector的方式。 在第一种方法中，通过reserve函数可以预留足够的内存空间，然后使用push_back函数逐个将元素添加到vector中。这种方法的好处是可以避免不必要的内存重分配，提高了效率。 而第二种方法使用new操作符在堆上分配内存空间，并使用memcpy函数将已有的vector对象的数据复制到新的内存空间中。通过这种方式，可以实现深拷贝，即两个vector对象拥有独立的内存空间。这种方法的好处是可以在不修改原始vector对象的情况下创建一个新的vector对象。 除了以上两种方法，还可以使用其他方式实现vector类。例如，可以使用动态数组来实现vector的底层数据结构，然后通过成员函数实现vector的各种操作，如增加、删除、查找等。 总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况选择。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值