vector 常见用法及模拟

于 2025-05-12 00:07:13 发布
阅读量912 收藏 26
点赞数 13
文章标签： c++ stl vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80541270/article/details/147861298
版权

文章目录

1. vector的介绍与使用

1.1 vector的构造

构造函数接口说明
vector ();无参构造
vector (size_type n, const value_type& val =value_type());构造并初始化n个val
vector (const vector& x);拷贝构造
vector (InputIterator first, InputIterator last);使用迭代器进行初始化构造
#include <iostream>
using namespace std;
#include <vector>

int main()
{
	vector<int> v1; // 无参构造
	vector<int> v2(10, 1); // 构造并初始化10个1
	vector<int> v3(v2); // 拷贝构造
	vector<int> v4(v3.begin(), v3.end()); // 使用迭代器构造
	return 0;
}

在这里插入图片描述

1.2 vector iterator 的使用

iterator 的使用接口说明
begin + end获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator
rbegin + rend获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator

在这里插入图片描述
在这里插入图片描述

int main()
{
	vector<int> v1; 
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	for (auto it = v1.begin(); it != v1.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	for (auto it = v1.rbegin(); it != v1.rend(); ++it) // 注意是++
	{
		cout << *it << " ";
	}
	cout << endl;
	return 0;
}

在这里插入图片描述

1.3 有关大小和容量的操作

容量空间接口说明
size获取数据个数
capacity获取容量大小
empty判断是否为空
resize改变vector的size
reserve改变vector的capacity
  • capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。
  • reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
  • resize在开空间的同时还会进行初始化，影响size。
int main()
{
	size_t sz;
	vector<int> v;
	sz = v.capacity();
	cout << "making v grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
	return 0;
}

  • vs：运行结果：vs下使用的STL基本是按照1.5倍方式扩容
    making foo grow:
    capacity changed: 1
    capacity changed: 2
    capacity changed: 3
    capacity changed: 4
    capacity changed: 6
    capacity changed: 9
    capacity changed: 13
    capacity changed: 19
    capacity changed: 28
    capacity changed: 42
    capacity changed: 63
    capacity changed: 94
    capacity changed: 141

  • g++运行结果：linux下使用的STL基本是按照2倍方式扩容
    making foo grow:
    capacity changed: 1
    capacity changed: 2
    capacity changed: 4
    capacity changed: 8
    capacity changed: 16
    capacity changed: 32
    capacity changed: 64
    capacity changed: 128

1.4 vector 增删查改

vector 增删查改接口说明
push_back尾插
pop_back尾删
find查找（这不是vector的成员函数）
insert在pos之前插入val
erase删除pos位置的数据
swap交换两个vector的数据空间
operator[]像数组一样访问
int main()
{
	vector<int> v;
	v.push_back(1); // 尾插
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	for (auto it = v.begin(); it != v.end(); ++it)
		cout << *it << ' ';
	cout << endl;
	v.pop_back(); // 尾删
	for (auto it = v.begin(); it != v.end(); ++it)
		cout << *it << ' ';
	cout << endl;

	auto pos = find(v.begin(), v.end(), 2); // 查找
	v.insert(pos, 5); // 插入
	for (auto it = v.begin(); it != v.end(); ++it)
		cout << *it << ' ';
	cout << endl;

	pos = find(v.begin(), v.end(), 1);
	v.erase(pos); // 删除

	vector<int> v1;
	for (auto it = v1.begin(); it != v1.end(); ++it)
		cout << *it << ' ';
	cout << endl;

	v.swap(v1); // 交换
	for (auto it = v.begin(); it != v.end(); ++it)
		cout << *it << ' ';
	cout << endl;
	for (auto it = v1.begin(); it != v1.end(); ++it)
		cout << *it << ' ';
	cout << endl;

	cout << v1[2] << endl; //像数组一样访问
	return 0;
}

运行结果：
在这里插入图片描述

1.5 vector 迭代器失效问题（重点）

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。

可能造成vector可能会导致其迭代器失效的操作有：

  1. 引起底层空间改变的操作，都可能会导致迭代器失效，比如：resize、reserve、insert、assign、push_back等。（简单来说，就是vector扩容问题，vector旧空间被释放掉，又访问了旧空间，很明显是野指针问题）
    解决方法：完成上述操作之后，重新给 it 赋值就行。
  2. 指定位置元素的删除操作–erase
    被删除元素之后的迭代器失效：所有指向被删除元素及其之后元素的迭代器、指针或引用都会失效，因为这些元素的位置已经发生了移动。
    所以，你可以发现 erase 的返回值是一个迭代器，可以用以修正迭代器失效问题。
    值得一提的是 vs 和 g++ 的区别:
    vs 上因为检查比较严格，所以迭代器失效会直接报错，而 g++ 检查并没有那么严格，还是能输出。
    • vs：
      在这里插入图片描述
    • g++：
      在这里插入图片描述
  3. 其实 string 在扩容、删除之后，也会出现迭代器失效的问题，但是其实大部分时候其实我们都是把它当成数组来处理。

1.6 vector 中二维数组的使用

int main()
{
	int n, m;
	cin >> n >> m;
	vector<vector<int>> vv(n, (vector<int>(m, 0)));
	return 0;
}

其实也好理解，<>号中存的是模板参数，而二维数组就是每个一维元素里存的都是一个一维数组，后面的 (n, vector(m, 0)) 就表示 n 个一维数组，这一维数组中的每个元素都是 m 个用 0 填充的一维数组。
当然，每个一维数组也可以用 reverse 重置大小，用以实现不规则数组。

2. vector 的模拟实现

vector 其实就只有三个指针而已：
_start：指向动态分配内存块的起始位置（即首个元素的地址）
_finish：指向最后一个有效元素的下一个位置
_end_of_storage：指向当前分配内存块的末尾地址

值得一讲的地方有两点，一点是拷贝构造和赋值重载的现代写法，另一点是 vector 使用 memcpy 拷贝问题

2.1 拷贝构造和赋值重载的现代写法

和 string 类一样，先实现一个交换数据域的类内 swap 成员函数，再利用编译器自己去构造一个我们要拷贝的对象，最后直接交换就可以了。

		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)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}

		vector<T>& operator=(vector<T> v)
		{
			swap(v);

			return *this;
		}

2.2 memcpy 拷贝问题

memcpy是按字节去拷贝，是浅拷贝，但是因为 vector 本身具有我们在堆上申请的资源，需要深拷贝，此时使用 memcpy 就会出现问题了，所以这里我们并不能使用memcpy，而是需要自己手动实现深拷贝。

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t old_size = size();
				T* tmp = new T[n];
				//memcpy(tmp, _start, old_size * sizeof(T));
				for (size_t i = 0; i < old_size; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;

				_start = tmp;
				_finish = tmp + old_size;
				_end_of_storage = tmp + n;
			}
		}

2.3 vector.h

前面说过模板最好不要进行头源文件分离，因为这样容易造成链接错误，所以这里代码全都放在 vector.h 中。

#pragma once
#include <assert.h>
#include <iostream>
#include <list>

namespace zkp
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		vector() = default;

		//vector(const vector<T>& v)
		//{
		//	reserve(v.size());
		//	for (auto& e : v)
		//	{
		//		push_back(e);
		//	}	
		//}

		// 需要一个迭代器模板函数，存在着多种不同类型的迭代器
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

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

		vector(int n, const T& val = T())
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		void clear()
		{
			_finish = _start;
		}

		/* 朴素写法
		vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				clear();

				reserve(v.size());
				for (auto& e : v)
				{
					push_back(e);
				}
			}

			return *this;
		}*/

		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)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}

		vector<T>& operator=(vector<T> v)
		{
			swap(v);

			return *this;
		}

		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
				//cout << _start << " " << _finish << " " << _end_of_storage << endl;
			}
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t old_size = size();
				T* tmp = new T[n];
				//memcpy(tmp, _start, old_size * sizeof(T));
				for (size_t i = 0; i < old_size; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;

				_start = tmp;
				_finish = tmp + old_size;
				_end_of_storage = tmp + n;
			}
		}

		void resize(size_t n, T val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

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

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}
		
		bool empty() const
		{
			return _start == _finish;
		}

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

			*_finish = x;
			++_finish;
		}

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

		iterator insert(iterator pos, const T& x)
		{
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : 2 * capacity());
				pos = _start + len;
			}

			auto end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;

			++_finish;

			return pos;
		}

		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 = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};


	template<class T>
	void print_vector(const vector<T>& v)
	{
		// 规定，没有实例化的类模板里面取东西，编译器不能区分这里const_iterator
		// 是类型还是静态成员变量
		// typename vector<T>::const_iterator it = v.begin();
		auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}

	template<class Container>
	void print_container(const Container& v)
	{
		/*auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;*/

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

	void test_vector1()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

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

		auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

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

		print_vector(v);

		vector<double> vd;
		vd.push_back(1.1);
		vd.push_back(2.1);
		vd.push_back(3.1);
		vd.push_back(4.1);
		vd.push_back(5.1);

		print_vector(vd);
	}

	void test_vector2()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		//v.push_back(5);

		print_vector(v);

		v.insert(v.begin() + 2, 30);
		print_vector(v);

		int x;
		cin >> x;
		auto p = find(v.begin(), v.end(), x);
		if (p != v.end())
		{
			// insert以后p就是失效，不要直接访问，要访问就要更新这个失效的迭代器的值
			//v.insert(p, 40);
			//(*p) *= 10;

			p = v.insert(p, 40);
			(*(p + 1)) *= 10;
		}
		print_vector(v);
	}

	void test_vector3()
	{
		std::vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);

		print_container(v);

		// 删除所有的偶数
		auto it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				it = v.erase(it);
			}
			else
			{
				++it;
			}
		}

		print_container(v);
	}

	void test_vector4()
	{
		int i = int();
		int j = int(1);
		int k(2);

		vector<int> v;
		v.resize(10, 1);
		v.reserve(20);

		print_container(v);
		cout << v.size() << endl;
		cout << v.capacity() << endl;

		v.resize(15, 2);
		print_container(v);

		v.resize(25, 3);
		print_container(v);

		v.resize(5);
		print_container(v);
	}

	void test_vector5()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		print_container(v1);

		vector<int> v2 = v1;
		print_container(v2);

		vector<int> v3;
		v3.push_back(10);
		v3.push_back(20);
		v3.push_back(30);

		v1 = v3;
		print_container(v1);
		print_container(v3);
	}

	void test_vector6()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(4);
		v1.push_back(4);

		vector<int> v2(v1.begin(), v1.begin() + 3);
		print_container(v1);
		print_container(v2);

		list<int> lt;
		lt.push_back(10);
		lt.push_back(10);
		lt.push_back(10);
		lt.push_back(10);
		vector<int> v3(lt.begin(), lt.end());
		print_container(lt);

		vector<string> v4(10, "111111111");
		print_container(v4);

		vector<int> v5(10);
		print_container(v5);

		vector<int> v6(10, 1);
		print_container(v6);

		vector<int> v7(10, 1);
		print_container(v7);
	}

	void test_vector7()
	{
		vector<string> v;
		v.push_back("11111111111111111111");
		v.push_back("11111111111111111111");
		v.push_back("11111111111111111111");
		v.push_back("11111111111111111111");
		print_container(v);

		v.push_back("11111111111111111111");
		print_container(v);
	}
}
std::vector 常用用法汇总和代码用例
小秋 AI SLAM 入门实战教程
01-11 1645
代码首先展示了如何添加、访问和删除元素，然后展示了如何遍历。最后，代码展示了如何使用。方法访问最后一个元素，并如何使用。在这段代码中，我演示了。，包括使用范围基于的。时会经常遇到的操作。
【STL】vector常见用法及模拟实现(附源码）
Mr_wang的博客
09-24 859
这篇文章我们来学习一下STL容器里的vector，我们先来学习一下它的使用，然后对vector进行模拟实现。vector文档介绍vector是一个大小可以更改的数组序列容器。其实这里可以简单认为vector就是之前数据结构学的顺序表。
C++—vector类的使用及模拟实现
渣檬Charman的博客
03-09 860
C++vector类的使用及模拟实现部分函数讲解
vector的使用及模拟实现
weixin_65592314的博客
03-11 1447
vector的介绍和基本使用，及模拟实现
C++vector类的常见函数以及其模拟实现
m0_52420323的博客
06-20 867
摘要：C++，vector，顺序表
C++vector常用接口函数及模拟实现
2301_78985459的博客
05-22 801
(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造memcpy是一个高效的内存复制工具，对于内置类型的数据能很好地工作。但在处理涉及资源管理的自定义类型时，必须小心浅拷贝带来的问题，建议使用深拷贝以确保资源的正确管理和释放。今天的分享到此为止，我们下期再见~
【爱上C++】vector用法详解
热门推荐
2301_76677973的博客
07-08 1万+
vector文档vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。
【C++】vector常见的使用方式
m0_64826370的博客
05-28 1305
在C++中，vector是一种动态数组容器，可以存储一系列具有相同数据类型的元素。它提供了一些操作函数，如插入、删除、访问等，使得对数组进行操作更加方便和灵活。可以在运行时动态调整大小，不需要事先指定大小；可以自动处理内存分配和释放，减少手动管理内存的工作量；提供了更多的操作函数，如插入、删除、查找等；可以通过下标访问元素。int main()cout << "删除前" << endl;cout << "删除后" << endl;// 删除 vec 的最后一个元素。
C++：vector模拟实现
Jdxxwu的博客
10-13 1097
本文将模拟实现vector~
vector使用方法与模拟实现
m0_74189279的博客
03-12 1302
介绍vector的使用方法以及模拟实现vector，内附完整代码。
C++STL之vector容器：基本使用及模拟实现
m0_63207201的博客
08-23 1255
vector的使用、vector的模拟实现、迭代器失效、memcpy拷贝问题、动态二维数组的理解
车载测试Vector工具CANoe-常见问题汇总（中）
02-03
### 车载测试Vector工具CANoe-...通过以上内容，我们可以了解到CANoe作为一款强大的车载测试工具，在实际使用过程中可能会遇到的一些常见问题及其解决方法。这些信息对于提高工作效率、减少故障排查时间具有重要意义。
Java学习教程，从入门到精通，Java Vector（向量）的语法知识点及语法知识点（57）
qq_45746668的博客
12-12 1472
Java 中的 `Vector` 类是一个同步的、动态数组，属于 `java.util` 包。它提供了动态数组的功能，可以随着元素的增加和删除自动调整大小。
深入探讨C++日志模块设计与实现
weixin_44727517的博客
05-07 607
日志系统是软件开发的"黑匣子"，在调试跟踪、问题定位、运行监控等方面发挥关键作用。一个优秀的日志模块应具备：精准的问题定位能力灵活的输出控制最小的性能损耗可靠的运行稳定性。
针对共享内存和上述windows消息机制 在C++ 和qt之间的案例 进行详细举例说明
安徽锐锋科技-沐雨潇竹
05-08 245
在此示例中，写入端将 QImage 序列化并写入共享内存，读取端从共享内存中读取并反序列化为 QImage。在此示例中，发送端使用 PostMessage 向目标窗口发送自定义消息，接收端在窗口过程函数中处理该消息。以下是关于在 C++ 和 Qt 中使用共享内存（QSharedMemory）和 Windows 消息机制（SendMessage / PostMessage）进行跨线程或跨进程通信的详细示例。线程间通信：对于线程间通信，Qt 提供了信号与槽机制，通常比共享内存或消息机制更为安全和高效。
C++双重释放内存问题
weixin_40398522的博客
05-09 426
在C++中，双重释放内存会导致未定义行为，通常引发程序崩溃这是因为同一块内存被多次释放会破坏内存管理器的内部数据结构双重释放是什么意思呢？
C/C++ 路由跟踪小程序实现
liulilittle的博客
05-08 322
复制代码到新建 traceroute.c 文件之中。
C++进阶学习：STL常用容器--stack容器
Miki Makimura 的博客
05-08 1290
stack 是一种先进后出的数据结构 只有一个出口不允许有遍历行为可以判断是否为空可以返回元素个数。
华为OD机试真题——单词接龙（首字母接龙）（2025A卷：100分）Java/python/JavaScript/C/C++/GO最佳实现
最新发布
专注分享技术、实用优质教程、资源
05-11 502
华为OD机试真题——单词接龙（首字母接龙）（2025A卷：100分）Java/python/JavaScript/C/C++/GO最佳实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值