vector的学习和模拟

最新推荐文章于 2025-08-31 22:50:31 发布

Jess07

最新推荐文章于 2025-08-31 22:50:31 发布

阅读量407

点赞数 4

CC 4.0 BY-SA版权

文章标签：学习 c++

本文链接：https://blog.csdn.net/weixin_48592440/article/details/150989909

vector是表示可变大小数组的序列容器。vector就像数组一样，采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。手册：https://cplusplus.com/reference/vector/vector/rbegin/

构造函数

#define _CRT_SECURE_NO_WARNINGS 
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

void test_vector1()
{
	vector<int> v1;  // 创建一个vector对象，v1;类型为vector<int>
	v1.push_back(1); // 尾插
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

	vector<int> v2(v1);  // 拷贝构造
	vector<int> v3;
	v3 = v2;             // 赋值
	for (size_t i = 0;i < v1.size();i++) // 下标访问
	{
		cout << v1[i] << " ";
	}
	cout << endl; 

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

三种访问元素的方式

void test_vector2()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	
	// 三种遍历  1、operator[]
	for (size_t i = 0;i < v1.size();i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;
	// 修改内容
	for (size_t i = 0;i < v1.size();i++)
	{
		v1[i] *= 2;
	}
	// 2、迭代器
	vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	// 3、范围for
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
}

迭代器：

1、获取第一个数据位置的iterator/const_iterator，获取最后一个数据的下一个位置的iterator/const_iterator

2、获取最后一个数据位置的reverse_iterator/const_reverse_iterator，获取第一个数据前一个位置的 reverse_iterator/const_reverse_iterator

reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。 resize在开空间的同时还会进行初始化，影响size。和string类类似。

void test_vector3()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << v1.size() << endl;
	cout << v1.capacity() << endl;
	cout << v1.empty() << endl;

	v1.reserve(10);               // 将capacity增大至10，size不变
	cout << v1.size() << endl;
	cout << v1.capacity() << endl;

	v1.resize(15);               // 将size增大至15，新开的空间，用0初始化，capacity也会相应增大
	cout << v1.size() << endl;
	cout << v1.capacity() << endl;
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
}

增删查改，和string不一样vector没有find接口，这个接口时algorithm库提供的。

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

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

	/*v1.pop_back();
	v1.pop_back();
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	v1.insert(v1.begin(), 0);  // 在第一个位置插入0
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;*/

	v1.insert(v1.begin()+v1.size(), 6); // 在末尾插入6
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	v1.erase(v1.begin(), v1.begin()+2); // 删除前2个数据
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	// find不是vector的成员函数，是algorithm的模板函数，需要包含头文件：algorithm
	vector<int>::iterator pos = find(v1.begin(), v1.end(),5); //在【fist，last)区间找，找到了返回该元素个迭代器
	if (pos != v1.end())   // 如果找不到会返回v1.end()
	{
		cout << *pos << endl;
		v1.erase(pos);  // 删除5
	}
	for (auto e : v1)
	{
		cout << e << " ";
	}
}

void test_vector5()
{
	vector<int> v1;
	v1.push_back(12);
	v1.push_back(2);
	v1.push_back(32);
	v1.push_back(24);
	v1.push_back(15);
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	sort(v1.begin(), v1.end()); // 排序，不是vector的成员函数，是algorithm的模板函数，需要包含头文件：algorithm
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
}

迭代器失效问题：

实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。

会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、 push_back等。

#include <iostream>
using namespace std;
#include <vector>
 
int main()
{
 vector<int> v{1,2,3,4,5,6};
 
 auto it = v.begin();
 
 // 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
v.resize(100, 8);
while(it != v.end()) // 报错；解决办法是在遍历之前it = v.begin();
 {
 cout<< *it << " " ;
 ++it;
 }
 cout<<endl;
 return 0;
}

指定位置元素的删除操作--erase

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

	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	auto it = v1.begin();
	/*while (it != v1.end()) // 错误删除，迭代器失效，删除2之后数据往前挪了，迭代器变为 “悬空” 状态。
	{
		if (*it % 2 == 0)
			v1.erase(it); // erase返回值是删除元素的下一个元素的迭代器

		else
			it++;
	}*/
	//
	while (it != v1.end())  // 
	{
		if (*it % 2 == 0)
			it=v1.erase(it);

		else
			it++;
	}

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

与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效；迭代器失效解决办法：在使用前，对迭代器重新赋值即可。

vector简单模拟实现

假如如上有一个数组，使用3个指针来描述，数组的起始地址和有效数据的下一位置和有效空间的下一个位置。

那么构造函数为：

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

~vector() // 析构
{
     if(_star)
      {
          delete[] _start;
          _start = _finish = _endofstorage = nullptr;
      }
			
}

拷贝构造

        // 拷贝构造1
		//vector(const vector<T>& v)
		//{
		//	_start = new T[v.capacity()];
		//	_finish = _start;
		//	_endofstorage = _start + v.capacity();

		//	for (size_t i = 0;i < v.size();i++)
		//	{
		//		*_finish = v[i];
		//		++_finish;
		//	}
		//}
		// 拷贝构造2--简洁版
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (const auto& e : v)
			{
				push_back(e);
			}
		}

赋值operator=

        // v1=v3;--1
		vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				delete[] _start;
				_start = new T[v.capacity];
				memcpy(_start, v._start, sizeof(T) * v.size());
			}
			return *this;
		}
		//// v1=v3;--2--这里会有三次赋值的时候有三次深拷贝，消耗很大（在algorithm的swap内部有三次深拷贝）
		//vector<T>& operator=( vector<T> v)
		//{
		//	swap(_start, v._start);
		//	swap(_finish, v._finish);
		//	swap(_endofstorage, v._endofstorage);
		//	return *this;
		//}
		//// v1=v3;--3
		//vector<T>& operator=(vector<T> v)  // v是v3的拷贝构造的临时容器拿去和v2交换，函数调用结束时调用v的析构函数释放v
		//{
		//	Swap(v);
		//	return *this;
		//}
		//void Swpa(vector<T>& v)
		//{
		//	swap(_start, v._start);
		//	swap(_start, v._finish);
		//	swap(_start, v._endofstorage);
		//}

迭代器

		// 迭代器
		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 sz = size();  // 获得旧空间的size，否则释放_start之后无法得到size
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);  // 按字节拷贝，将_start的元素拷贝到tmp，如果对象是vector<string>的时候会报错，因为是浅拷贝
					for (size_t i = 0;i < sz;i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = tmp + sz;
				_endofstorage = tmp + n;
			}
		}

尾插/尾删和随机插入

		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity(); // 如果容器为空那么开辟2个空间否则2倍开空间
				reserve(newcapacity);
			}
			*_finish = x;
			++_finish;
		}
		void pop_back()
		{
			assert(_start < _finish);
			--_finish;
		}
		void insert(iterator pos, const T& x)
		{
			assert(pos <= _finish);
			if (_finish == _endofstorage)
			{
				size_t n = pos - _start;   // 获得pos的下标,reserve之后，原本的_start的内存被释放了，pos成为野指针
				size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity();
				reserve(newcapacity);
				pos = _start + n;  // 在新空间中，找到pos位置
			}
			// 挪动数据
			iterator end = _finish - 1;// 最后一个数据的指针
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			_finish++;
		}

resize/

iterator erase(iterator pos)
		{
			assert(pos < _finish);

			iterator it = pos;
			while (it < _finish) // 将pos之后的数据往前挪一位，覆盖pos位置原数据
			{
				*it = *(it + 1);
				it++;
			}
			--_finish;

			return pos;
		}
		void resize(size_t n, const T& val = T())// 传的参数是未知的，可能是内置类型，也可能是自定义类型，所以用T()做缺省值
		{
			if (n < size())  // 调整_finish指向新的末尾即可
			{
				_finish = _start - n;
			}
			else
			{
				if (n > capacity()) // 增容
				{
					reserve(n);
				}
				while (_finish < _start + n)  // 从finish位置开始将数据初始化为val
				{
					*_finish = val;
					++_finish;
				}
			}
		}

		size_t size()
		{
			return _finish - _start;
		}
		size_t capacity()
		{
			return _endofstorage - _start;
		}
		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;
	};