【STL】vector模拟实现

已于 2024-02-13 09:05:37 修改
阅读量590 收藏 20
点赞数 27
分类专栏： C++初阶 文章标签： c++ 开发语言
于 2024-02-12 16:32:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70088010/article/details/133097350
版权

vector模拟实现

一、vector函数接口总览

namespace JRH
{
	// vector
	template<class T>
	class vector
	{
	public:
		// 1、默认的函数
		vector(); // 构造函数1
		vector(size_t n, const T& val); // 构造函数2
		template<class InputIterator>
		vector(InputIterator first, InputIterator last); // 构造函数3
		vector(const vector<T>& vt); // 拷贝构造
		vector<T>& operator=(const vector<T>& vt); // 运算符赋值重载函数
		~vector(); // 析构函数

		// 2、迭代器相关函数
		iterator begin(); // 头
		iterator end(); // 尾
		const_iterator begin() const; // const头
		const_iterator end() const; // const尾

		// 3、容器相关的函数
		size_t size() const; // 大小
		size_t capacity() const; // 容量
		void reserve(size_t n); // 保持容量
		void resize(size_t n, const T& val = T()); // 扩容
		bool empty() const; // 判空

		// 4、修改容器内容相关函数
		void push_back(const T& x);
		void pop_back();
		void insert(iterator pos, const T& x);
		iterator erase(iterator pos);
		void swap(vector<T>& v);

		// 5、访问容器相关函数
		T& operator[](size_t i);
		const T& operator[](size_t i)const;
	private:
		iterator _start;        //指向容器的头
		iterator _finish;       //指向有效数据的尾
		iterator _endofstorage; //指向容器的尾
	};
}

二、vector当中的成员介绍

在vector当中有三个成员变量_start、_finish、_endofstorage。

在这里插入图片描述

_start指向容器的头，_finish指向容器当中有效数据的尾，_endofstorage指向整个容器的尾。

三、list模拟实现

1、默认成员函数

（1）构造函数1

首先支持一个无参的构造函数，我们只需要将其三个变量都定为nullptr即可。

		vector() // 构造函数1
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorge(nullptr)
		{}

（2）构造函数2

vector还支持构造这样一种容器，该容器当中含有n个值为val的数据。对于该构造函数，我们可以先使用reserve函数将容器容量先设置为n，然后使用push_back函数尾插n个值为val的数据到容器当中即可。

		vector(size_t n, const T& val) // 构造函数2
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{
			reserve(n); // 调用下面写的reverse函数将其空间先定义为n个
			// 尾插n个val值进入到vector中
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

注意：

  1. 这个reverse函数有大用，我们要开好刚好的n个的空间，因为避免调用push_back函数时需要增容多次，导致效率降低。
  2. 该构造函数还需要实现两个重载函数（int和long）。
		vector(int n, const T& val) // 构造函数2 -- 重载int
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n); // 调用下面写的reverse函数将其空间先定义为n个
			// 尾插n个val值进入到vector中
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		vector(long n, const T& val) // 构造函数2 -- 重载long
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n); // 调用下面写的reverse函数将其空间先定义为n个
			// 尾插n个val值进入到vector中
			for (long i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

（3）构造函数3

vector还支持使用一段迭代器区间进行对象的构造。因为该迭代器区间可以是其他容器的迭代器区间，也就是说该函数接收到的迭代器的类型是不确定的，所以我们这里需要将该构造函数设计为一个函数模板，在函数体内将该迭代器区间的数据一个个尾插到容器当中即可。

		template<class InputIterator>
		vector(InputIterator first, InputIterator last) // 构造函数3
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			// 将迭代器中的所有区间的值全部都放进vector中
			while (first != last)
			{
				// this->push_back(*first);
				push_back(*first);
				first++;
			}
		}

2、拷贝构造函数

（1）写法一：老式写法

先开辟一块与该容器大小相同的空间，然后将该容器当中的数据一个个拷贝过来即可，最后更新_finish和_endofstorage的值即可。

		vector(const vector<T>& vt) // 拷贝构造
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			// 先开一块相同大小的空间
			_start = new T[vt.capacity()];
			for (size_t i = 0; i < vt.size(); i++) // 一个个拷贝过去
			{
				_start[i] = vt[i];
			}
			_finish = _start + vt.size(); // 有效数据的尾
			_endofstorage = _start + vt.capacity(); // 整个数组的尾
		}

注意： 将容器当中的数据一个个拷贝过来时不能使用memcpy函数，当vector存储的数据是内置类型或无需进行深拷贝的自定义类型时，使用memcpy函数是没什么问题的，但当vector存储的数据是需要进行深拷贝的自定义类型时，使用memcpy函数的弊端就体现出来了。例如，当vector存储的数据是string类的时候。

在这里插入图片描述
并且vector当中存储的每一个string都指向自己所存储的字符串。
在这里插入图片描述

如果此时我们使用的是memcpy函数进行拷贝构造的话，那么拷贝构造出来的vector当中存储的每个string的成员变量的值，将与被拷贝的vector当中存储的每个string的成员变量的值相同，即两个vector当中的每个对应的string成员都指向同一个字符串空间。

在这里插入图片描述

这结果是肯定错误的，因为都指向同一块空间了，假如销毁原字符串用memcpy拷贝构造的函数也销毁了，那么我们看一下代码是怎么实现的：
在这里插入图片描述

代码中看似是使用普通的“=”将容器当中的数据一个个拷贝过来，实际上是调用了所存元素的赋值运算符重载函数，而string类的赋值运算符重载函数就是深拷贝，所以拷贝结果是这样的：

在这里插入图片描述

  • 如果vector当中存储的元素类型是内置类型（int）或浅拷贝的自定义类型（Date），使用memcpy函数进行进行拷贝构造是没问题的，但如果vector当中存储的元素类型是深拷贝的自定义类型（string），则使用memcpy函数将不能达到我们想要的效果。

（2）写法二：现代写法

现代写法比较简单且暴力，直接一个for循环将其一个个放到this指针的push_back中即可，也就是一个个尾插过来即可。
在使用范围for对容器v进行遍历的过程中，变量e就是每一个数据的拷贝，然后将e尾插到构造出来的容器当中。就算容器v当中存储的数据是string类，在e拷贝时也会自动调用string的拷贝构造（深拷贝），所以也能够避免出现与使用memcpy时类似的问题。

		vector(const vector<T>& vt) // 拷贝构造 -- 现代写法
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(vt.capacity()); // 开辟一段vt等大的空间
			for (auto e : vt)
			{
				push_back(e); // 将容器vt中的数据一个个尾插进来
			}
		}

3、赋值运算符重载函数

（1）写法一：传统写法

首先判断是否是给自己赋值，若是给自己赋值则无需进行操作。若不是给自己赋值，则先开辟一块和容器v大小相同的空间，然后将容器v当中的数据一个个拷贝过来，最后更新_finish和_endofstorage的值即可。
同样也不能用memcpy函数进行拷贝，其原理与上面的拷贝构造函数是一样的。

		vector<T>& operator=(const vector<T>& vt) // 运算符赋值重载函数 -- 传统写法
		{
			if (this != &vt) // 不能自己给自己赋值
			{
				delete[] _start; // 释放原来的空间
				_start = new T[vt.capacity()]; // 开辟一块与vt等大的空间
				for (size_t i = 0; i < vt.size(); i++)
				{
					_start[i] = vt[i]; // 将vt里面的数据一个个拷贝过来
				}
				_finish = _start + vt.size(); // 有效数据的大小
				_endofstorage = _start + vt.capacity(); // 整个数组的大小
			}
			return *this; // 支持连续赋值
		}

（2）写法二：现代写法

首先在右值传参时并没有使用引用传参，因为这样可以间接调用vector的拷贝构造函数，然后将这个拷贝构造出来的容器v与左值进行交换，此时就相当于完成了赋值操作，而容器v会在该函数调用结束时自动析构。

赋值运算符重载的现代写法也是进行的深拷贝，只不过是调用的vector的拷贝构造函数进行的深拷贝，在赋值运算符重载函数当中仅仅是将深拷贝出来的对象与左值进行了交换而已。

		vector<T>& operator=(const vector<T> vt) // 运算符赋值重载函数 -- 现代写法
		{
			std::swap(vt); // 交换这两个值
			return *this; // 支持连续赋值
		}

4、析构函数

析构函数很简单，但有细节，是析构函数首先要判断是不是空指针，不可释放空指针，非空指针后先释放原空间，再将三个变量置空即可。

		~vector() // 析构函数
		{
			if (_start != nullptr) // 避免对空指针进行曹组
			{
				delete[] _start; // 释放空间
				_start = nullptr; 
				_finish = nullptr;
				_endofstorage = nullptr;
			}
		}

四、迭代器相关函数

我们的迭代器就是容器当中所存储数据类型的指针，我们首先定义两个迭代器，一个是iterator，另一个是const_iterator，我们看一下下面的定义：

		typedef T* iterator;
		typedef const T* const_iterator;

1、begin和end

begin()就是返回该vector的首元素的地址，end()返回容器当中有效数据的下一个数据的地址。我们看一下下面的代码：

		iterator begin() // 头
		{
			return _start; // 返回头元素地址
		}
		iterator end() // 尾
		{
			return _finish; // 返回有效数据的下一个元素地址
		}

2、const对象的begin和end

const对象的begin和end函数是和上面一样的，只不过重载了上面的两个函数，我们直接显示代码即可：

		const_iterator begin() const // const头
		{
			return _start; // 返回头元素地址
		}
		const_iterator end() const // const尾
		{
			return _finish; // 返回有效数据的下一个元素地址
		}

3、使用演示

第一种我们可以用迭代器iterator来进行演示：

		for (size_t i = 0; i < v.size(); ++i)
		{
			std::cout << v[i] << " ";
		}
		std::cout << std::endl;

第二种我们用for循环来进行演示，因为for循环可以用的情况下也就是底层的是迭代器也可以进行使用。

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

五、容器和大小相关函数

1、size和capacity

vector当中三个成员遍历各自的指向，我们可以很容易得出当前容器中的有效数据个数和最大容量。
在这里插入图片描述
size()就是已用空间的大小，也就是_finish-_start；capacity()就是总空间的大小，也就是_endofstorage-_start。

		size_t size() const // 大小
		{
			return _finish - _start;
		}
		size_t capacity() const // 容量
		{
			return _endofstorage - _start;
		}

2、reserve

  1. 当n大于对象当前的capacity时，将capacity扩大到n或大于n。
  2. 当n小于对象当前的capacity时，什么也不做。

reserve函数的实现思路也是很简单的，先判断所给n是否大于当前容器的最大容量（否则无需进行任何操作），操作时直接开辟一块可以容纳n个数据的空间，然后将原容器当中的有效数据拷贝到该空间，之后将原容器存储数据的空间释放，并将新开辟的空间交给该容器维护，最好更新容器当中各个成员变量的值即可。

		void reserve(size_t n) // 保持容量
		{
			if (n > capacity()) // 判断是否需要进行操作
			{
				size_t sz = size(); // 保存一下有效数据的个数
				T* tmp = new T[n]; // 开辟一个可以容纳n个空间的tmp
				if (_start)
				{
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i]; // 将原本容器中的所有数据都拷贝到tmp临时空间中
					}
					delete[] _start; // 释放原空间
				}
				_start = tmp; // 将tmp临时空间中的数据全都放到对象容器当中
				_finish = _start + sz; // 有效数据个数
				_endofstorage = _start + n; // 总容量大小
			}
		}

细节问题1、在进行操作之前需要提前记录当前容器当中有效数据的个数。

我们在进入循环记录了一下有效数据的大小sz，这是因为我们最后需要更新_finish指针的指向，而_finish指针的指向就等于_start指针加容器当中有效数据的个数，当_start指针的指向改变后我们再调用size函数通过_finish - _start计算出的有效数据的个数就是一个随机值了。

在这里插入图片描述

细节问题2、拷贝容器当中的数据时，不能使用memcpy函数进行拷贝。

可能你会想，当vector当中存储的是string的时候，虽然使用memcpy函数reserve出来的容器与原容器当中每个对应的string成员都指向同一个字符串空间，但是原容器存储数据的空间不是已经被释放了，相当于现在只有一个容器维护这这些字符串空间，这还有什么影响。
但是不要忘了，当你释放原容器空间的时候，原容器当中存储的每个string在释放时会调用string的析构函数，将其指向的字符串也进行释放，所以使用memcpy函数reserve出来的容器当中的每一个string所指向的字符串实际上是一块已经被释放的空间，访问该容器时就是对内存空间进行非法访问。
在这里插入图片描述

所以还是用for循环和=将其一个个赋值过来才是王道：
在这里插入图片描述

3、resize

  1. 当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
  2. 当n小于当前的size时，将size缩小到n。

根据resize函数的规则，进入函数我们可以先判断所给n是否小于容器当前的size，若小于，则通过改变_finish的指向，直接将容器的size缩小到n即可，否则先判断该容器是否需要增容，然后再将扩大的数据赋值为val即可。

		void resize(size_t n, const T& val = T()// 模板缺省值) // 扩容
		{
			if (n < size()) // 当n小于当前的size时
			{
				_finish = _start + n; // 将size缩小到n
			}
			else // 当n大于当前的size时
			{
				if (n > capacity()) // 判断是否需要增容
				{
					reserve(n);
				}
				while (_finish < _start + n) // 将size扩大到n
				{
					*_finish = val;
					_finish++;
				}
			}
		}

4、empty

只需要比较_start和_finish的位置是否相同即可，相同则空了，不相同则非空。

		bool empty() const // 判空
		{
			return _start == _finish;
		}

六、修改容器内的相关函数

1、push_back

简单，判断是否容器已经满了，满了就扩容，然后将数据尾插到_finish指向的位置，再将_finish++即可。

		void push_back(const T& x)
		{
			if (_finish == _endofstorage) // 到容量底了
			{
				reserve(capacity() == 0 ? 4 : 2 * capacity());
			}
			*_finish = x;
			_finish++;
		}

2、pop_back

简单，先进行判空，这里用assert断言即可，方便快捷，非空则直接将_finish--即可。

		void pop_back()
		{
			assert(!empty());
			--_finish;
		}

3、insert

insert函数可以在所给迭代器pos位置插入数据，在插入数据前先判断是否需要增容，然后将pos位置及其之后的数据统一向后挪动一位，以留出pos位置进行插入，最后将数据插入到pos位置即可。

		void insert(iterator pos, const T& x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start; // 记录一下相差大小
				// 扩容
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = _start + len;
			}

			iterator end = _finish - 1; // 将pos位置及其之后的数据统一向后挪动一位，以留出pos位置进行插入
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x; // 插入 
			++_finish;  // 往后移一位
		}

4、erase

erase函数可以删除所给迭代器pos位置的数据，在删除数据前需要判断容器释放为空，若为空则需做断言处理，删除数据时直接将pos位置之后的数据统一向前挪动一位，将pos位置的数据覆盖即可。

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			iterator start = pos + 1;
			// 将pos位置之后的数据统一向前挪动一位，以覆盖pos位置的数据
			while (start != _finish)
			{
				*(start - 1) = *start;
				++start;
			}
			--_finish;
		}

5、swap

直接用std库中的swap函数即可，用其进行交换三个变量，这里的std::域作用限定符告诉编译器这里优先在全局范围寻找swap函数，否则编译器会认为你调用的就是你正在实现的swap函数（就近原则）。

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

七、访问容器相关函数

只有一个operator[]来进行访问，实现时直接返回对应位置的数据即可。

1、operator[]

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

2、const operator[]

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

这里的权限只需要读，不能写。

八、代码总览

stl_vector.h:

#include<iostream>
#include<cassert>

namespace JRH
{
	// vector
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
	public:
		// 1、默认的函数
		vector() // 构造函数1
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}
		vector(size_t n, const T& val) // 构造函数2
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{
			reserve(n); // 调用下面写的reverse函数将其空间先定义为n个
			// 尾插n个val值进入到vector中
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		vector(int n, const T& val) // 构造函数2 -- 重载int
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n); // 调用下面写的reverse函数将其空间先定义为n个
			// 尾插n个val值进入到vector中
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		vector(long n, const T& val) // 构造函数2 -- 重载long
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n); // 调用下面写的reverse函数将其空间先定义为n个
			// 尾插n个val值进入到vector中
			for (long i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		template<class InputIterator>
		vector(InputIterator first, InputIterator last) // 构造函数3
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			// 将迭代器中的所有区间的值全部都放进vector中
			while (first != last)
			{
				// this->push_back(*first);
				push_back(*first);
				first++;
			}
		}
		vector(const vector<T>& vt) // 拷贝构造 -- 传统写法
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			// 先开一块相同大小的空间
			_start = new T[vt.capacity()];
			for (size_t i = 0; i < vt.size(); i++) // 一个个拷贝过去
			{
				_start[i] = vt[i];
			}
			_finish = _start + vt.size(); // 有效数据的尾
			_endofstorage = _start + vt.capacity(); // 整个数组的尾
		}
		//vector(const vector<T>& vt) // 拷贝构造 -- 现代写法
		//	:_start(nullptr)
		//	, _finish(nullptr)
		//	, _endofstorage(nullptr)
		//{
		//	reserve(vt.capacity()); // 开辟一段vt等大的空间
		//	for (auto e : vt)
		//	{
		//		push_back(e); // 将容器vt中的数据一个个尾插进来
		//	}
		//}
		vector<T>& operator=(const vector<T>& vt) // 运算符赋值重载函数 -- 传统写法
		{
			if (this != &vt) // 不能自己给自己赋值
			{
				delete[] _start; // 释放原来的空间
				_start = new T[vt.capacity()]; // 开辟一块与vt等大的空间
				for (size_t i = 0; i < vt.size(); i++)
				{
					_start[i] = vt[i]; // 将vt里面的数据一个个拷贝过来
				}
				_finish = _start + vt.size(); // 有效数据的大小
				_endofstorage = _start + vt.capacity(); // 整个数组的大小
			}
			return *this; // 支持连续赋值
		}
		//vector<T>& operator=(const vector<T> vt) // 运算符赋值重载函数 -- 现代写法
		//{
		//	std::swap(vt); // 交换这两个值
		//	return *this; // 支持连续赋值
		//}
		~vector() // 析构函数
		{
			if (_start != nullptr) // 避免对空指针进行曹组
			{
				delete[] _start; // 释放空间
				_start = nullptr; 
				_finish = nullptr;
				_endofstorage = nullptr;
			}
		}

		// 2、迭代器相关函数
		iterator begin() // 头
		{
			return _start; // 返回头元素地址
		}
		iterator end() // 尾
		{
			return _finish; // 返回有效数据的下一个元素地址
		}
		const_iterator begin() const // const头
		{
			return _start; // 返回头元素地址
		}
		const_iterator end() const // const尾
		{
			return _finish; // 返回有效数据的下一个元素地址
		}

		// 3、容器相关的函数
		size_t size() const // 大小
		{
			return _finish - _start;
		}
		size_t capacity() const // 容量
		{
			return _endofstorage - _start;
		}
		void reserve(size_t n) // 保持容量
		{
			if (n > capacity()) // 判断是否需要进行操作
			{
				size_t sz = size(); // 保存一下有效数据的个数
				T* tmp = new T[n]; // 开辟一个可以容纳n个空间的tmp
				if (_start)
				{
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i]; // 将原本容器中的所有数据都拷贝到tmp临时空间中
					}
					delete[] _start; // 释放原空间
				}
				_start = tmp; // 将tmp临时空间中的数据全都放到对象容器当中
				_finish = _start + sz; // 有效数据个数
				_endofstorage = _start + n; // 总容量大小
			}
		}
		void resize(size_t n, const T& val = T()) // 扩容
		{
			if (n < size()) // 当n小于当前的size时
			{
				_finish = _start + n; // 将size缩小到n
			}
			else // 当n大于当前的size时
			{
				if (n > capacity()) // 判断是否需要增容
				{
					reserve(n);
				}
				while (_finish < _start + n) // 将size扩大到n
				{
					*_finish = val;
					_finish++;
				}
			}
		}
		bool empty() const // 判空
		{
			return _start == _finish;
		}

		// 4、修改容器内容相关函数
		void push_back(const T& x)
		{
			if (_finish == _endofstorage) // 到容量底了
			{
				reserve(capacity() == 0 ? 4 : 2 * capacity());
			}
			*_finish = x;
			_finish++;
		}
		void pop_back()
		{
			assert(!empty());
			--_finish;
		}
		void insert(iterator pos, const T& x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start; // 记录一下相差大小
				// 扩容
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = _start + len;
			}

			iterator end = _finish - 1; // 将pos位置及其之后的数据统一向后挪动一位，以留出pos位置进行插入
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x; // 插入 
			++_finish;  // 往后移一位
		}
		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			iterator start = pos + 1;
			// 将pos位置之后的数据统一向前挪动一位，以覆盖pos位置的数据
			while (start != _finish)
			{
				*(start - 1) = *start;
				++start;
			}
			--_finish;
		}
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

		// 5、访问容器相关函数
		T& operator[](size_t i)
		{
			assert(i < size());
			return _start[i];
		}
		const T& operator[](size_t i) const
		{
			assert(i < size());
			return _start[i];
		}
	private:
		iterator _start;        //指向容器的头
		iterator _finish;       //指向有效数据的尾
		iterator _endofstorage; //指向容器的尾
	};
	void test_vector1()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.pop_back();
		//v.pop_back();
		for (size_t i = 0; i < v.size(); ++i)
		{
			std::cout << v[i] << " ";
		}
		std::cout << std::endl;

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

		vector<int>::iterator it = v.begin();
		while (it != v.end())
		{
			std::cout << *it << " ";
			it++;
		}
		std::cout << std::endl;

		v.resize(2);
		std::cout << v.capacity() << std::endl;
		std::cout << v.size() << std::endl;
	}
}

main.cc:

#include"stl_vector.h"

int main()
{
	JRH::test_vector1();

	return 0;
}
2022horse
关注
  • 27
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
STL vector 模拟实现
叫我小秦就好了的博客
01-09 648
vector 的数据结构安排及操作方式，与原生数组十分相似，两者唯一的差别在于空间运用的灵活性。原生数组是静态空间，一旦配置了就不能改变大小；vector 是动态空间，可以在插入过程中动态调整空间大小。vector 的实现技术，关键在于它对大小的控制及重新配置时的数据移动效率。
STL中vector的模拟实现
fengjunziya的博客
04-30 233
简介:STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。网上有句话说：“不懂STL，不要说你会C++”。STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构，以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。而我们，则应该学会如何使用它，理解它，再到实现它。
STL之vector模拟实现
m0_62211222的博客
10-29 662
vector的中文意思是向量，他可以容纳很多类型的数据，因此vector也被称为容器。看到前面的解释可能你一脸蒙逼，下面我给出两种简单的理解。可以把vector理解为是一个可以动态增长的数组，一个数组可以存储多个相同类型的数据。也可以理解成是一个顺序表，里面可以存储不同类型的数据其实这两种说法本质都是一样的，因为顺序表就是用数组实现的。vector是c++的一个类，他像前面我介绍过的string类（没看过的同学看这里：）一样，有public函数，也有private成员。
C++ STL --- vector类模拟实现
weixin_57761086的博客
08-29 1212
C++STL之vector的模拟实现，模拟实现了构造模块、迭代器模块、容量模块、元素访问模块、修改模块。同时讲解了为什么不能用memset和memecpy函数。使用大量代码举例子。
C++ [STL之vector模拟实现]
ARMCSKGT的博客
05-27 5228
vector是STL容器容器之一，其底层实现类似于数据结构顺序表，相当于string来说得益于泛型模板的加持使得vector可以变为任何类型，且是可以动态扩容，堪称大号数组！在vector的实现中，有许多值得我们学习的细节，接下来将为大家一 一介绍！
C++ STL中 vector 的模拟实现
Butayarou的博客
03-20 1375
文章目录一、前言二、模拟实现的意义何在？三、vector类的模拟实现成员函数：0.迭代器相关函数begin 函数end 函数1.构造函数2.析构函数3.拷贝构造函数4.赋值重载函数5. size 函数6. capacity 函数7. swap 函数 一、前言 在C++的STL中，vector 是一个顺序容器，代表一个可动态增长的数组。因此，自己在进行模拟实现时，跟写动态顺序表类似。 vector 是一个类模板。 推荐的 C/C++ 参考文档：http://www.cplusplus.com 二、模拟实现
【C++】STL——vector模拟实现
M的博客
06-20 1359
vector的模拟实现
C++ vector模拟实现
Wzs040810的博客
01-10 3492
C++ STL vector模拟实现
C++ STL之vector的使用及模拟实现
czh1592272237的博客
01-21 912
本篇文章详细讲解了STL中vector的使用及模拟实现。
stl——模拟实现vector
smx_dd的博客
01-13 386
对于vector相信大家并不陌生，这里介绍一些重要的vector的接口和用法。 1. 构造函数 vector(); 无参构造 vector(size_type n, const value_type& val = value_type()); 构造并初始化n个val vector (InputIterator first, InputIterator last); 利用迭代器进行构造。 ...
vector 模拟实现
03-20
在本模拟实现中，我们将探讨如何根据《C++ Primer》一书中的指导，创建一个基本的`vector`类，关注其核心功能，如内存管理、动态增长和STL（标准模板库）接口的兼容性。以下是对这个模拟实现的一些关键知识点的详细...
模拟vector的简易实现
07-21
下面我们将深入探讨`vector`的关键特性，并提供一个简单的模拟实现。 1. **动态内存分配**： `std::vector`的一个主要特点是它能够根据需要动态地增加或减少容量。在C++中，这通常通过调用`new`和`delete`操作符来...
C++的Vector实现.zip
08-20
本项目的目标是实现一个自定义的`Myvector`类，模拟`std::vector`的部分功能。 `std::vector`的核心特性包括： 1. 动态增长：当向vector中添加元素，且当前容量不足时，vector会自动分配更大的内存空间并复制现有...
c++习题08-计算星期几
码到成龚的博客
07-03 606
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初探究（2）
最新发布
Frenemy__的博客
07-09 1038
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 925
Android 开发中 C++ 和Java 日志调试方法小结
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 896
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
模拟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
发出的红包

打赏作者

2022horse

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值