C++——vector的简介及使用

Posted 2021-12-07 小倪同学 -_-

文章目录

• vector简介
• vector的使用
• • vector的定义
  • vector迭代器的使用
  • • begin和end
    • rbegin和rend
  • vector 空间增长
  • • size和capacity
    • empty
    • reserve和resize
  • vector 增删查改
  • • push_back和pop_back
    • insert和erase
    • find
    • swap
    • operator[ ]
  • vector迭代器失效问题
  • • 底层空间改变导致迭代器失效
    • 指定位置元素的删除操作

vector简介

vector文档

1. vector是表示可变大小数组的序列容器
2. 和数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小增加存储空间。其做法是，开辟一个新的数组，然后将全部元素移到这个数组并释放原来的空间。
4. vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。
5. vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。

vector的使用

vector的定义

int main()
{
	vector<int> v1;							//构造int类型的空容器
	vector<int> v2(10, 2);					//构造含有10个2的int类型容器
	vector<int> v3(v2);						//拷贝构造int类型的v2容器的复制
	vector<int> v4(v2.begin(), v2.end());	//使用迭代器拷贝构造v2容器的某一段内容
}

vector迭代器的使用

如下图

begin和end

通过begin函数可以得到容器中第一个元素的正向迭代器，通过end函数可以得到容器中最后一个元素的后一个位置的正向迭代器。

int main()
{
	vector<int> v;
	v.push_back(1); // 尾插
	v.push_back(2); 
	v.push_back(3);
	v.push_back(4);
	//正向迭代器遍历
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	return 0;
}

rbegin和rend

通过rbegin函数可以得到容器中最后一个元素的反向迭代器，通过rend函数可以得到容器中第一个元素的前一个位置的反向迭代器。

int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	//正向迭代器遍历
	vector<int>::reverse_iterator rit = v.rbegin();
	while (rit != v.rend())
	{
		cout << *rit << " ";
		rit++;
	}
	cout << endl;
	return 0;
}

vector 空间增长

size和capacity

int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);

	cout << v.size() << endl;	//获取当前容器中的有效元素个数
	cout << v.capacity()<<endl;	//获取当前容器的最大容量
	return 0;
}

empty

容器为空返回1，否则返回0

int main()
{
	vector<int> v1;
	vector<int> v2;
	v2.push_back(1);


	cout << v1.empty() << endl;
	cout << v2.empty() << endl;

	return 0;
}

reserve和resize

reserve规则：

1. 当所给值大于容器当前的capacity时，将capacity扩大到该值。
2. 当所给值小于容器当前的capacity时，什么也不做。

resize规则：

1. 当所给值大于容器当前的size时，将size扩大到该值，扩大的元素为第二个所给值，若未给出，则默认为0。
2. 当所给值小于容器当前的size时，将size缩小到该值。

int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	cout << v.size() << endl; 
	cout << v.capacity() << endl; 
	v.reserve(10); //改变容器的capacity为10，size不变
	cout << v.size() << endl; 
	cout << v.capacity() << endl; 
	v.resize(8); //改变容器的size为8
	cout << v.size() << endl;
	cout << v.capacity() << endl; 
	return 0;
}

vector 增删查改

push_back和pop_back

int main()
{
	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();
	v.pop_back();
	v.pop_back();

	return 0;
}

insert和erase

int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	v.insert(v.begin(), 0);				//在容器开头插入0
	v.insert(v.begin(), 3, -1);			//在容器开头插入3个-1
	
	v.erase(v.begin());					//删除第一个元素
	v.erase(v.begin(), v.begin() + 3);	//删除前三个元素

	return 0;
}

find

find函数共三个参数，前两个参数确定一个迭代器区间（左闭右开），第三个参数确定所要寻找的值。find函数在所给迭代器区间寻找第一个匹配的元素，并返回它的迭代器，若未找到，则返回所给的第二个参数。

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

int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int> v(a, a + sizeof(a) / sizeof(int));

	// 使用find查找3所在位置的iterator
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);

	// 在pos位置之前插入30
	v.insert(pos, 30);

	// 输出打印
	vector<int>::iterator it = v.begin();
	while (it != v.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}

注意： find函数是在算法模块当中实现的，不是vector的成员函数,需要引头文件#include <algorithm>。

swap

int main()
{
	vector<int> v1(5, 1);
	vector<int> v2(5, 2);

	v1.swap(v2); //交换v1,v2的数据空间

	return 0;
}

operator[ ]

vector当中实现了 [ ] 操作符的重载，我们可以像数组一样通过“下标+[ ]”的方式对容器当中的元素进行访问。

int main()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	// 使用[ ]遍历访问
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	return 0;
}

vector迭代器失效问题

迭代器的主要作用就是让算法能够不用关心底层数据结构，vector迭代器底层实际就是一个指针,因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃。

底层空间改变导致迭代器失效

int main()
{
	vector<int> v{ 1, 2, 3, 4, 5 };
	auto it = v.begin();
	v.reserve(10);
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}

迭代器失效原因： vector扩容时底层原理旧空间被释放掉，而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃。

指定位置元素的删除操作

int main()
{
	vector<int> v{ 1, 2, 3, 4, 5, 6 };
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0) //删除容器当中的全部偶数
		{
			v.erase(it);
		}
		it++;
	}
	return 0;
}

上述代码乍一看没什么问题，但是运行却会报错，这是为什么呢？

仔细分析一下我们会发现，当把最后一位数据6删除时，v.begin和v.end指向同一块空间，但是v.begin还要往后移动，指向一块不属于容器V的空间，程序崩溃。

我们可以通过接收erase函数的返回值（erase函数返回删除元素的后一个元素的新位置）避免上述情况

int main()
{
	vector<int> v{ 1, 2, 3, 4, 5, 6 };
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0) 
		{
			it = v.erase(it); //删除并获取下一个元素的迭代器
		}
		else
		{
			it++;
		}		
	}
	return 0;
}