【STL学习】（4）vector的模拟

于 2024-04-06 00:47:07 发布
阅读量773 收藏 29
点赞数 34
分类专栏： C++初阶 文章标签： c++ 学习 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangjiushun/article/details/137213150
版权

前言

本文将模拟实现vector的常用功能，目的在于更深入理解vector。

一、前置知识

  1. 在模拟之前先对vector的结构和常用接口学习，有一个大致了解。
  2. 看源码，本文参考的源码是SGI版本的stl3.0。
    • 技巧：
      • 看源码不要一行一行的看，要先看框架，了解整体框架
      • 看源码要学会猜，根据单词的意思去猜它想表达什么。规范的代码，每一个名字都有它的含义。
      • 总结：一看框架；二去猜（带着猜想，去验证）。
    • 看框架的步骤：
      • 先看成员变量
      • 再看成员函数
  3. 参考vector的源码：
    • vector的成员变量：是三个原生指针变量（设为原生指针类型有什么好处，在模拟时讲解）在这里插入图片描述
    • vector的成员函数：vector的常用接口讲解链接
  4. STL中的容器因为需要频繁的申请和释放空间，所以STL中提供了内存池（allocator类模板），内存池的本质是先在堆区中申请一定的空间留作备用，当有新的内存需求时，就从内存池中分出一块内存块，若内存块不够再继续申请新的内存，这样可以提高内存分配的效率。现阶段我们只是简单模拟vector，所以我们这没有使用内存池，而是直接在堆区申请空间，后期会讲解内存池的。

二、vector常用接口的模拟

1、vector的成员变量

vector的成员变量是三个原生指针T*：

  1. _start：开始位置，即指向第一个元素的位置
  2. _finish：结束位置，即指向最后一个元素的下一个位置
  3. _end_of_storage：存储结束位置在这里插入图片描述
    虽然vector使用的是三个原生指针，但是可以通过指针运算得到size和capacity。

代码示例：

//为了避免与库中的vector冲突，将其封装在wjs的命名空间中
namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		//获取容器中的元素个数
		size_t size()const//内部不改变成员变量，建议加上const——普通对象和const对象都可以调用
		{
			//指针-指针=两者之间的元素个数
			return _finish - _start;
		}

		//获取为当前容器分配的存储空间
		size_t capacity()const//内部不改变成员变量，建议加上const——普通对象和const对象都可以调用
		{
			//指针-指针=两者之间的元素个数
			return _end_of_storage - _start;
		}
	private:
		iterator _start;//开始位置，指向第一个元素
		iterator _finish;//结束位置，指向最后一个元素的下一个位置
		iterator _end_of_storage;//指向存储结束位置
	};
}

tip：

  1. 使用命名空间将我们模拟实现的vector封装，避免命名冲突。
  2. 类模板的定义与实现不分离，后续在模板进阶讲解。
  3. size和capacity可以通过指针-指针得到，注意指针-指针运算有一个前提是：物理存储空间是连续的。
  4. const成员：
    • const修饰的是*this，即const成员函数的内部不能修改成员变量
    • 建议只要成员函数内部不修改成员变量，都应该加const，这样普通对象和const对象都可以调用

2、vector的默认成员函数

构造函数：

  • 构造函数：创建类对象时，编译器自动调用，给成员变量赋初值
  • 类的成员变量建议在初始化列表初始化
  • 成员变量为内置类型需要我们手动初始化，不然为随机值；成员变量为自定义类型不初始化，会去调用它的默认构造（建议每个类，都要有一个默认构造）
  • vector的常用构造函数：
    • 默认构造函数：一般使用最多，构造一个空的vector，即将每个成员初始化为空
    • 构造并初始化n个val：先初始化成员变量，再复用reserve开n的空间，最后再通过尾插将val插入容器
    • 使用迭代器初始化构造：先初始化成员变量，再将迭代器区间的数据尾插入容器

析构函数：

  • 析构函数：对象销毁时，编译器自动调用，完成对象中资源的清理
  • 编译器生成的析构函数，对内置类型不做处理，自定义类型会去调用它的析构函数
  • 当类涉及动态资源的申请时，就需要显式实现析构释放资源。

赋值重载函数：

  • 赋值重载函数：已经存在的两个对象复制拷贝
  • 当类涉及资源管理时，就需要自己显示实现完成深拷贝，编译器默认生成的赋值重载函数只能完成浅拷贝
  • 赋值重载深拷贝的现代写法：让形参去调用拷贝构造，去帮我们开空间拷贝数据，之后与形参交换（函数结束后形参销毁，也顺便帮我们把旧空间释放了）
  • 现代写法无法避免自己给自己赋值的情况，当现实中也很少会出现

拷贝构造函数：

  • 拷贝构造函数：用一个已经存在的对象初始化另一个对象
  • 注意：拷贝构造只有一个参数，并且必须是本类型的引用（使用传值会引发无限递归）
  • 编译器默认生成的拷贝构造也是只能完成浅拷贝，所以当类涉及资源管理时，就需要自己显式实现完成深拷贝
  • 拷贝构造深拷贝的现代写法：自己开空间，自己拷贝数据

总结：当类涉及资源管理时，拷贝构造、赋值重载、析构都需要显式实现。

//为了避免与库中的vector冲突，将其封装在wjs的命名空间中
namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		//默认构造函数
		vector()
			//初始化列表：成员变量定义的地方，建议在初始化列表初始化成员变量
			//成员变量为内置类型不初始化，为随机值
			:_start(nullptr),
			_finish(nullptr),
			_end_of_storage(nullptr)
		{}
		//构造并初始化n个val
		vector(size_t n, const T& val = T())//T()调用构造函数
			//初始化成员变量
			:_start(nullptr),
			_finish(nullptr),
			_end_of_storage(nullptr)
		{
			//复用reserve，开空间
			reserve(n);
			//复用push_back，尾插n个val
			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)
		{
			//复用push_back，将迭代器区间[first，last)的数据尾插进容器
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		//当wjs::vector<int> v(10, 1);报错——》 error C2100: 非法的间接寻址
		//函数重载，调用时会走最匹配的，wjs::vector<int> v(10, 1)两个参数类型都是int，所以他走使用迭代器构造
		//重载一个vector(int n, const T& val = T())，他就会走构造n个val
		//构造并初始化n个val
		vector(int n, const T& val = T())//T()调用构造函数
			//初始化成员变量
			:_start(nullptr),
			_finish(nullptr),
			_end_of_storage(nullptr)
		{
			//复用reserve，开空间
			reserve(n);
			//复用push_back，尾插n个val
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}
		
		//交换两个vector对象
		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<T>& operator=(vector<T> v)//形参v直接就去调用拷贝构造，帮我们开空间可拷贝数据了
		{
			//与v交换
			swap(v);
			return *this;
		}

		//拷贝构造函数
		vector(const vector<T>& v)
		{
			//传统写法：自己开空间自己拷贝
			_start = new T[v.capacity()];
			//注意不能使用memcpy，它只能完成浅拷贝
			for (size_t i = 0; i < v.size(); ++i)
			{
				//当T为自定义类型时，会去调用的它的赋值重载，完成深拷贝
				_start[i] = v._start[i];
			}
			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

		//析构函数
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
		}
	};
}

tip：

  • 重载函数，在调用时，会走匹配的。
  • T()：T是一个模板参数，所以T()是一个任意类型的匿名对象。如果T是定义类型会去调用它的默认构造（从这点建议每个类都需要有一个默认构造），如果是内置类型也去调用内置类型的默认构造。
  • 理论上内置类型是没有构造函数的，但是有了模板之后，C++对此做了特殊处理，对内置类型做了升级，也提供了构造。
  • 结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，可能会引起内存泄漏甚至程序崩溃。

3、vector的遍历

迭代器：

  • begin（）：返回指向容器的第一个元素的位置的迭代器
  • end（）：返回指向容器最后一个元素的下一个位置的迭代器
  • begin和end一般会实现两个版本：普通版本和const版本
  • 有了迭代器，就可以使用范围for，因为范围for的底层就是替换为begin和end

operator[]：

  • operator []越界是断言处理（断言只在debug下会生效，release下不生效）
  • operator[]一般也会实现两个版本：一个返回普通引用，一个返回常引用
//为了避免与库中的vector冲突，将其封装在wjs的命名空间中
namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		//普通版本迭代器——迭代器可读可写
		iterator begin()
		{
			//返回指向第一个元素的位置的迭代器
			return _start;
		}
		iterator end()
		{
			//返回指向最后一个元素的下一位置的迭代器
			return _finish;
		}
		//const版本迭代器——迭代器只可读
		const_iterator begin()const
		{
			//返回指向第一个元素的位置的const迭代器
			return _start;
		}
		const_iterator end()const
		{
			//返回指向最后一个元素的下一位置的const迭代器
			return _finish;
		}

		//operator[]
		//普通版本——返回普通引用，可读可写
		T& operator[](size_t pos)
		{
			//operator[]越界断言
			assert(pos >= 0 && pos < size());
			//返回pos位置元素的引用
			return _start[pos];
		}
		//cosnt版本——返回const引用，只可读
		const T& operator[](size_t pos)const
		{
			//operator[]越界断言
			assert(pos >= 0 && pos < size());
			//返回pos位置元素的常引用
			return _start[pos];
		}
	};
}

4、vector的reserve和resize

resize：

  • resize将容器大小调整为n
    • 如果n小于当前容器大小，则内容将减少到其前n个元素，删除超出的部分
    • 如果n大于当前容器大小，则通过在末尾插入所需数量的元素来扩展内容，以达到n的大小。如果指定了val，则新元素将初始化为val的副本，否则，它们将进行值初始化
    • 注意：如果n也大于当前容器容量，则会自动重新分配存储空间

reserve：

  • reserve请求改变容器的capacity，只有当n>当前容量时，reserve才会重新分配空间，将其容量增加到n（或更大）
namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		//调整容器的size
		void resize(size_t n, const T& val = T())
		{
			//如果n>size
			if (n > size())
			{
				//如果n>capacity，一次扩容，避免多次扩容
				reserve(n);
				//尾插val，使size=n
				while (_finish < _start + n)
				{
					push_back(val);
					//++_finish;尾插之后finish会+1，所以这里不能再重复+1了
				}
			}
			else
			{
				//n<size，使size=n，调整_finish的位置即可
				_finish = _start + n;
			}
		}

		//调整容器容量
		void reserve(const size_t n)
		{
			//只有n>capacity时，才会重新开空间，将其capacity增加到n
			if (n > capacity())
			{
				size_t old_size = size();
				iterator tmp = new T[n];
				//判断
				if (_start)
				{
					//memcpy是浅拷贝，所以当拷贝的自定义类型且涉及资源管理时，就会报错！
					//memcpy(tmp, _start, sizeof(T) * old_size);
					for (size_t i = 0; i < old_size; ++i)
					{
						//当T为自定义类型时会去调用它的赋值重载,完成深拷贝
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				//_start的改变会影响size，所以需要在前面将旧size保存
				_finish = _start + old_size;
				_end_of_storage = _start + n;
			}
		}
	};
}

tip：

  • memcpy是内存的二进制格式拷贝，将一段内存空间中的内容原封不动的拷贝到另一段内存空间中，即memcpy是浅拷贝
  • 当memcpy拷贝的内容不涉及资源管理时，memcpy即高效又不会出错，但当memcpy拷贝的是自定义类型且涉及资源管理时，就会出错，因为memcpy不能完成深拷贝在这里插入图片描述
  • 结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，可能会引起内存泄漏甚至程序崩溃。

5、vector的插入

push_back：

  • 尾插，在vector的末尾插入x
  • 尾插需要注意：①尾插之前需要检查是否扩容；②尾插之后size+1，即++_finish
namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		//尾插
		void push_back(const T& x)
		{
			//插入之前判断是否需要扩容
			if (_finish == _end_of_storage)
			{
				//扩容
				size_t new_capacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(new_capacity);
			}
			//尾插
			*_finish = x;
			++_finish;
		}
	};
}

insert：

  • 在pos位置的元素之前插入x
  • insert需要注意：①断言pos位置是否合理；②插入之前检查是否需要扩容；③插入之后需要更新size
namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		//pos位置的元素之前插入
		void insert(iterator pos, const T& x)
		{
			//断言pos位置是否合理
			assert(pos >= _start && pos <= _finish);
			//插入之前判断是否需要扩容
			if (_finish == _end_of_storage)
			{
				//扩容
				size_t new_capacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(new_capacity);
			}
			//[pos, _finish - 1]的数据向后挪动，将pos位置空出
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			//pos位置插入x
			*pos = x;
			++_finish;
		}
	};
}

tip：

  • insert在pos位置的元素之前插入x，需要向后挪动数据，在模拟实现string的时候，我们使用的是下标，当是头插的时候，结束条件我们不好控制，因为size_t不会小于0，我们当时使用了npos，现在vector使用iterator就不会出现这种情况了。

测试代码：

//测试insert
void test_vector04()
{
	wjs::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.push_back(7);
	v.push_back(8);
	for (auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

运行结果：

在这里插入图片描述

分析：

在这里插入图片描述
修改1：

namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		//pos位置的元素之前插入
		void insert(iterator pos, const T& x)
		{
			//断言pos位置是否合理
			assert(pos >= _start && pos <= _finish);
			//插入之前判断是否需要扩容
			//注意：扩容之后需要更新pos，否则pos指向释放的旧空间，会造成迭代器失效
			if (_finish == _end_of_storage)
			{
				//计算pos与_start的相对距离
				size_t len = pos - _start;
				//扩容
				size_t new_capacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(new_capacity);
				//更新pos
				pos = _start + len;
			}
			//[pos, _finish - 1]的数据向后挪动，将pos位置空出
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			//pos位置插入x
			*pos = x;
			++_finish;
		}
	};
}

测试代码：

//测试insert
void test_vector04()
{
	wjs::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.push_back(7);
	v.push_back(8);
	for (auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	//头插100
	auto pos = v.begin();
	v.insert(pos, 100);
	//插入之后修改pos位置的元素
	*pos += 10;
	cout << *pos << endl;
	for (auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

运行结果：

在这里插入图片描述

分析：

  • 扩容之后，在insert中更新pos只解决了内部迭代器失效的问题，外面的pos并没有解决，它仍指向一块已经释放的空间。
  • 思考：那我们可以将pos参数设为引用，内部的改变也影响外面吗？
    答案是：不可以，因为引用的权限可以平移或缩小，但是不可以放大。当外面传的pos迭代器为一个const迭代器时，引用权限被放大，这是错误的，那将参数也设为常引用呢，这也不可以，因为常引用就不可以修改pos了。
  • insert解决外部pos迭代器失效的方法是插入之后，返回修改的pos迭代器（即指向新插入的第一个元素的迭代器）。

修改2：

namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		//pos位置的元素之前插入
		iterator insert(iterator pos, const T& x)
		{
			//断言pos位置是否合理
			assert(pos >= _start && pos <= _finish);
			//插入之前判断是否需要扩容
			//注意：扩容之后需要更新pos，否则pos指向释放的旧空间，会造成迭代器失效
			if (_finish == _end_of_storage)
			{
				//计算pos与_start的相对距离
				size_t len = pos - _start;
				//扩容
				size_t new_capacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(new_capacity);
				//扩容之后更新pos，解决内部pos失效问题
				pos = _start + len;
			}
			//[pos, _finish - 1]的数据向后挪动，将pos位置空出
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			//pos位置插入x
			*pos = x;
			++_finish;
			//返回形参pos，解决外部pos失效问题
			return pos;
		}
	};
}

测试代码：

void test_vector04()
{
	wjs::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.push_back(7);
	v.push_back(8);
	for (auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	//头插100
	auto pos = v.begin();
	//insert之后，pos迭代器可能会失效(扩容)
	//记住，insert之后就不要使用这个pos迭代器，因为它可能失效了
	//使用这个pos迭代器是一个高危行为
	//如果非要使用这个pos这个位置的迭代器，可以接收insert的返回值
	//insert的返回值就是指向pos这个位置的迭代器
	auto ret = v.insert(pos, 100);
	*ret += 10;
	cout << *ret << endl;
	for (auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

tip：

  • insert之后，pos迭代器可能会失效(扩容)
  • 记住，insert之后就不要使用这个pos迭代器，因为它可能失效了
  • 使用这个pos迭代器是一个高危行为

push_back可以复用insert：

namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		//尾插
		void push_back(const T& x)
		{
			插入之前判断是否需要扩容
			//if (_finish == _end_of_storage)
			//{
			//	//扩容
			//	size_t new_capacity = capacity() == 0 ? 4 : 2 * capacity();
			//	reserve(new_capacity);
			//}
			尾插
			//*_finish = x;
			//++_finish;

			//复用insert
			insert(_finish, x);
		}
	};
}

6、vector的删除

erase：

  • 删除pos位置的元素
  • erase需要注意：①断言pos位置是否合理（即有没有数据）；②删除之后更新size，即_finish。

思考： erase存在迭代器失效吗？

在这里插入图片描述

  • erase删除pos位置元素后，迭代器的意义变了（指向删除的最后一个元素之后的元素的新位置，理论上迭代器并没有失效，因为删除并没有改变底层空间）
  • 注意：如果pos是最后一个元素，删除之后pos刚好是_finish的位置，而_finish位置是没有元素的，所以pos迭代器失效
  • VS系列下检测比较严格，删除vector任意位置上的元素，都认为该位置迭代器失效了
  • Linux下，g++编译器对迭代器失效的检测就相对佛系，处理没有VS下极端，只有删除vector最后一个元素，才认为迭代器失效了（在实际场景中，迭代器的意义变了，也容易出现各种问题）
  • 总结：vector 迭代器对象在erase或insert后，不能再访问这个迭代器，我们都认为它失效了，访问结果是未定义的。
  • erase通过返回一个指向删除的最后一个元素之后的元素的新位置迭代器解决迭代器失效问题。
namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		//删除pos位置的元素
		iterator erase(iterator pos)
		{
			//断言pos是否合理
			assert(pos >= _start && pos < _finish);
			//删除pos位置元素，即将[pos+1, _finish - 1]的元素向前挪动
			iterator begin = pos + 1;
			while (begin < _finish)
			{
				*(begin - 1) = *begin;
				++begin;
			}
			--_finish;
			//erase通过返回一个指向删除的最后一个元素之后的元素的新位置迭代器解决迭代器失效问题，即pos迭代器
			return pos;
		}
	};
}

测试代码：

void test_vector05()
{
	wjs::vector<int> v2;
	v2.push_back(1);
	v2.push_back(2);
	v2.push_back(2);
	v2.push_back(3);
	v2.push_back(4);
	v2.push_back(5);
	v2.push_back(6);
	for (auto& e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
	//删除所有偶数
	auto it2 = v2.begin();
	while (it2 != v2.end())
	{
		if (*it2 % 2 == 0)
		{
			//erase之后迭代器失效
			//解决方案：it2需要接收erase的返回值
			it2 = v2.erase(it2);
		}
		else
		{
			++it2;
		}
	}
	for (auto& e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
}

tip：

  • insert和erase之后的迭代器失效，是通过接收返回值解决的

pop_back：

  • 尾删，删除vector中的最后一个元素，尾删之后size-1
  • 这里直接复用erase即可
namespace wjs
{
	//类模板的实现和定义不分离，后续学到模板进阶会讲解！
	template<class T>
	class vector
	{
	public:
		void pop_back()
		{
			//复用erase
			erase(_finish - 1);
		}
	};
}
从前慢，现在也慢
关注
  • 34
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vector 模拟实现
03-20
对vector 的实现的模拟。使用《c++ primar》 中的部分代码，并进行了完善。
C++STL详解（四）—— vector的模拟实现
2021dragon的博客
08-03 2927
vector的模拟实现
模拟vector
weixin_42817333的博客
06-19 80
实现vector构造，析构，增加，删除，迭代器实现，运算符重载
vector的简单模拟
Enthusiastic_boy的博客
04-13 923
目录 构造与析构 简单方法的模拟 拷贝构造与赋值运算符重载 浅拷贝问题 深拷贝 扩容 reserve() resize() 插入与删除 push_back() insert() erase() 构造与析构 模拟实现时，依然使用vector作为容器的名字，为了防止与std命名空间中的vector冲突，使用自定义的命名空间，将模拟实现的类放入即可。vecotr容器中可以存储多种类型的值，所以需要使用模板的方式。类的实现方法也有多种，以下实现采用三指针的方式，比如容器中的有效元素.
模拟实现Vector
qq_42185602的博客
04-20 132
#include<iostream> #include<assert.h> #include<string.h> #include<algorithm> using namespace std; template<class T> class Vector{ typedef T* Iterator; typedef const T*...
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
c++ vector模拟实现代码
08-25
在C++标准模板库(STL)中，`vector`是一个非常关键的容器，它提供了类似于动态数组的功能。本文将深入探讨`vector`的实现原理，并通过一个简单的模拟代码来展示其核心机制。 首先，`vector`是一个序列容器，它允许在...
C++的Vector实现.zip
08-20
本项目的目标是实现一个自定义的`Myvector`类，模拟`std::vector`的部分功能。 `std::vector`的核心特性包括： 1. 动态增长：当向vector中添加元素，且当前容量不足时，vector会自动分配更大的内存空间并复制现有...
模拟实现vector
小葱的博客
04-28 541
vector.h#pragma once #define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std;//vector的插入和删除都存在迭代器失效的问题，解决方法将插入和删除的函数 //的参数给成引用，可以达到如下结果：当上述两个函数内部迭代器失效，也会使得 //外部的迭代器也同样失效，那么就要在函数内部将其重置
vector的模拟实现
weixin_45975835的博客
11-19 110
vector的模拟实现 最近学习了vector的使用，下面对vctor进行了模拟实现， 如有不足请指出： #include<iostream> #include<assert.h> #include<vector> using namespace std; template<class T> class Vector { public: Vector() :_start(nullptr) ,_finish(nullptr) ,_endOf
vector模拟实现
m0_60447315的博客
09-23 1344
💖 作者简介：大家好，我是菀枯😜💬格言：不要在低谷沉沦自己，不要在高峰上放弃努力！☀️大家在学习C++的时候一定会学到STL（标准模板库），这是C++标准库中最重要的组成部分，它包含了常用的数据结构和算法。今天呢，我们首先来学习STL中的vector容器vector的数据安排和操作方式与我们平时使用的数组非常相似，唯一的区别在于数组是一个固定空间，而vector的空间可以随着元素的改变而发生改变。还是和之前一样，vector的使用方式大家可以去查阅官方文档欢迎各位参考与指导！！！
[STL]: 模拟实现vector
何如是
09-07 95
1.vector的介绍与使用接口 1.1 vector是什么 vector是一种序列式容器 其底层实现原理和数组一样，但不同的是，它的大小可动态改变 与其他序列式容器相比vector的随机访问使访问效率更加高效(O(1)) 1.2 iterator的使用 //vector的使用 #include<vector> int main() { vector<int> vt...
【STL】之Vector的模拟实现
f2016913的博客
03-07 789
一：迭代器失效？ 前面我们了解迭代器其实就是智能指针，可以通过运算符的操作来实现接口函数，但有时有会存在安全隐患。这就是我们常说的迭代器失效。所谓的迭代器失效其实是找某个位置的元素，删除，然后再通过operator++，operator--访问下一个元素，会出现野指针造成崩溃的问题； 如下： #include #include using namespace std; void Test
简单模拟vector的实现
Hlun的博客
10-17 449
运用类型萃取，模拟string，简单模拟vector。。。。
模拟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、付费专栏及课程。

余额充值