C++ Vector（向量容器）：特点，使用方式及迭代器失效问题

最新推荐文章于 2022-07-30 19:40:54 发布

WangJ_F_

最新推荐文章于 2022-07-30 19:40:54 发布

阅读量1.6k

点赞数

分类专栏： STL

本文链接：https://blog.csdn.net/W_J_F_/article/details/87537610

版权

STL 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

vector介绍

vector是一个线性顺序结构。相当于数组，但其大小可以不预先指定，并且自动扩展。它可以像数组一样
被操作，由于它的特性我们完全可以将vector 看作动态数组。
就像数组一样，创建一个vector 后，它会自动在内存中分配一块连续的内存空间进行数据存储，初始的空
间大小可以预先指定也可以由vector 默认指定，这个大小即capacity （）函数的返回值，也就是意味着可
以采用下标对vector的元素进行访问，和数组一样高效，但是又不像数组，它的大小是可以动态改变的，
而且大小是容器自动处理
vector使用动态分配数组来储存它的元素，当新元素插入时，这个数组需要被重新分配大小，为了
增加储存空间，其做法是，分配一个新的数组，然后将全部元素移到这个数组，代价相对高，所以
当一个新元素加入容器时，vector并不会每次都重新分配大小
当存储的数据超过分配的空间时vector 会重新分配一块内存块，但这样的分配是很耗时的，在重新分配
空间时它会做这样的动作：
首先，vector 会申请一块更大的内存块；
然后，将原来的数据拷贝到新的内存块中；
其次，销毁掉原内存块中的对象（调用对象的析构函数）；
最后，将原来的内存空间释放掉。
如果vector 保存的数据量很大时，这样的操作一定会导致糟糕的性能（这也是vector 被设计成比较容易拷贝的值类型的原因）。所以说vector 不是在什么情况下性能都好，只有在预先知道它大小的情况下vector 的性能才是最优的。
vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，所以储存空间比实际需要的
储存空间更大
与其他序列容器相比（deque，lists，forward_lists）,vector在访问元素的时候更加高效，在末尾
添加和删除元素相对高效，对于其他不在末尾的删除插入操作，效率更低

vector特点

空间可以动态扩展。即它可以像数组一样操作，并且可以进行动态操作。通常体现在push_back() pop_back() 。
随机访问方便，它像数组一样被访问，即支持[ ] 操作符和vector.at()（假设v是一个vector对象，则v.at(n)和v[n]是一样的，只不过前者会检查是否越界（因此花费的时间稍多），而后者不会（后者越界会导致未定义行为）。）
节省空间，因为它是连续存储，在存储数据的区域都是没有被浪费的，但是要明确一点vector 大多情况下并不是满存的，在未存储的区域实际是浪费的。
在内部进行插入、删除操作效率非常低，这样的操作基本上是被禁止的。Vector 被设计成只能在后端进行追加和删除操作，其原因是vector 内部的实现是按照顺序表的原理，使得中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中
只能在vector 的最后进行push 和pop ，不能在vector 的头进行push 和pop
当动态添加的数据超过vector 默认分配的大小时要进行内存的重新分配、拷贝与释放，这个操作非常消耗性能。所以要vector 达到最优的性能，最好在创建vector 时就指定其空间大小

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>
#include<vector>
int main()
{
	std::vector<int> first;//无参构造.
	std::vector<int> second(2,10);//初始化两个10
	std::vector<int> third(second);//拷贝构造
	std::vector<int> fourth(second.begin,second.end);//使用迭代器进行初始化构造

	return 0;
}

vector iterator的使用

iterator的使用	接口说明
begin()	获取第一个数据位置的iterator
end()	获取最后一个数据的下一个位置的iterator
rbegin()	获取最后一个数据位置的reverse_iterator
rend()	获取第一个数据前一个位置的reverse_iterator
cbegin()	获取第一个数据位置的const_iterator
cend()	获取最后一个数据的下一个位置的const_iterator

#include<iostream>
#include<vector>
void Print(const std::vector<int>& v)
{
//使用const迭代器进行遍历打印
	std::vector<int>::const_iterator it = v.begin();
	while (it != v.end())
	{
	    std::cout << *it << " ";
		++it;
	}
	std::cout << std::endl;
}
int main()
{
	std::vector<int> v;
	v.push_back(1);//插入数据
	v.push_back(2);
	v.push_back(3);
	//使用迭代器进行遍历打印
	std::vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		std::cout << *it << " ";
		++it;
	}
	std::cout << std::endl;
	//使用迭代器进行改造
	it = v.begin();
	while (it != v.end())
	{
		*it *= 2;
		++it;
	}
	//使用反向迭代器进行遍历在打印
	std::vector<int>::reverse_iterator rit = v.rbegin();
	while (rit != v.rend())
	{
		std::cout << *rit << " ";
		++rit;
	}
	std::cout << std::endl;

	Print(v);

	return 0;
}

vector空间增长问题

容量空间	接口说明
size()	获取数据个数
capacity(）	获取容量大小
empty（）	判断是否为空
void resize (size_type n, value_type val = value_type());	改变vector的size
void reserve (size_type n);	改变vector放入capacity

capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的
具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问
题
resize在开空间的同时还会进行初始化，影响size

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	size_t sz;
	vector<int> foo;
	sz = foo.capacity();
	cout << "making foo grow:\n";
	for (int i = 0;i < 100;++i)
	{
		foo.push_back(i);
		if (sz != foo.capacity())
		{
			sz = foo.capacity();
			cout << "capacity change :" << sz << '\n';
		}
	}
	return 0;
}
//运行结果vs1.5倍，g++2倍

std::vector<int> bar;
	sz = bar.capacity();
	bar.reserve(100); // reserve直接开辟100个capacity
	std::cout << "making bar grow:\n";
	for (int i = 0; i<100; ++i) {
		bar.push_back(i);
		if (sz != bar.capacity()) {
			sz = bar.capacity();
			std::cout << "capacity changed: " << sz << '\n';
		}
	}

//与上面循环开辟相比：如果预先知道需要空间大小可直接开辟
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
making bar grow:
capacity changed: 100


#include <iostream>
#include <vector>
int main()
{
	std::vector<int> v;
	for (int i = 1;i < 10;i++)
		v.push_back(i);

	for (int i = 0;i<v.size();i++)

		std::cout << ' ' << v[i];
	std::cout << std::endl;

	v.resize(5);
	v.resize(8, 100);
	v.resize(12,1);
	v.resize(14);
	
	for (int i = 0;i<v.size();i++)
		std::cout << ' ' << v[i];
	std::cout << std::endl;
	return 0;
}
//运行结果：resize重置个数，可多可少，多了默认0
1 2 3 4 5 6 7 8 9
1 2 3 4 5 100 100 100 1 1 1 1 0 0

vector增删查改

vector增删查改	接口说明
void push_back (const value_type& val);	尾插
void pop_back();	尾删
InputIterator find (InputIterator first, InputIterator last, const T& val);	查找。（注意这个是算法模块实现，不是 vector的成员接口）
iterator insert (iterator position, const value_type& val);	在position之前插入val
iterator erase (iterator position);	删除position位置的数据
void swap (vector& x);	交换两个vector的数据空间
reference operator[] (size_type n);	像数组一样访问

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	int a[] = {1,2,3,4};
	int i = 0;
	vector<int> v(a,( a + sizeof(a)/sizeof(int)) );//迭代器初始化a为首元素地址
	//使用find查找3所在位置
	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())
	{
		//vector像数组一样定位
		cout << v[i]<<" ";
		i++;
		it += 1;
	}
	cout << endl;
	pos = find(v. begin(), v.end(), 2);
	//删除pos位置数据

	return 0;
}

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	int a[] = {1,2,3,4};
	vector<int> v(a,(a+sizeof(a)/sizeof(int)) );
	//通过[i]的方式遍历
	for (size_t i = 0; i < v.size();++i)
	{
		cout << v[i] << "";
	}
	cout << endl;

	vector<int> s;
	s.swap(v);
	cout << "v data:";
	for (size_t i = 0; i < v.size(); ++i)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	cout << "s data:";
	for (size_t i = 0; i < s.size(); ++i)
	{
		cout << s[i] << " ";
	}
	cout << endl;
	//1234
	//v data :
	//s data : 1 2 3 4交换后v无元素

	//c++支持新式遍历
	for (auto x : s)
	{
		cout << x << " ";
	}
	cout << endl;

	return 0;
}

vector迭代器失效问题

迭代器原理：

// Vector的迭代器是一个原生指针
typedef T* Iterator;
typedef const T* ConstIterator;

Iterator Begin() { return _start; }
Iterator End() { return _finish;  }

ConstIterator CBegin() const { return _start; }
 ConstIterator CEnd() const { return _finish; }

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int> v(a, a + sizeof(a) / sizeof(int));
	// 实现删除v中的所有偶数
	// 下面的程序会崩溃掉，如果是偶数，erase导致it失效
	// 对失效的迭代器进行++it，会导致程序崩溃
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
			v.erase(it);
		++it;
	}

	// 以上程序要改成下面这样，erase会返回删除位置的下一个位置
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
			it = v.erase(it);
		else
			++it;
	}
	return 0;
}

// insert/erase导致的迭代器失效
#include <iostream>
#include <algorithm>
#include <vector>
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位置的数据，导致pos迭代器失效。
	v.erase(pos);
	cout << *pos << endl; // 此处会导致非法访问
				
						  // 在pos位置插入数据，导致pos迭代器失效。
						  // insert会导致迭代器失效，是因为insert可
						  // 能会导致增容，增容后pos还指向原来的空间，而原来的空间已经释放了。
	pos = find(v.begin(), v.end(), 3);
	v.insert(pos, 30);
	cout << *pos << endl; // 此处会导致非法访问
	return 0;
}

通过sdt::data()函数获取数据指针
可将vector当成数组使用
vecotr<int> v (3,0);
int *p = v.data();

总结

总结：迭代器的失效分三种情况，分为数组形，链表性，树形数据结构

数组形数据结构：该数据结构元素是分配在连续的内存中。

链表性数据结构：其也是用了不连续分配的内存

树形数据结构：插入不会使得任何迭代器失效。

对于序列式容器：vector，queue等，序列式容器就是数组式容器，删除当前的iterator会使得后边所有元素的iterator都失效。这是因为其使用了连续分配的内存，删除一个元素导致后面所有的元素都会向前移动一个位置，所以不能使用erase(iter++)的方式。（在删除后对迭代器自增，实际其本身已经失效了。）但是erase方法可以返回下一个有效的iterator
对于关联式容器如（map,set,multimap,multiset）,删除当前的iterator，仅仅会使当前的iterator失效，只要在erase时，递增当前iterator即可。这是因为map之类的容器，使用了红黑树来实现，插入、删除一个节点不会对其他节点造成影响，erase迭代器只是被删元素的迭代器失效，但是返回值为void，所以要采用erase(iter++)（erase(iter)之后，iterator就已经失效了，所以iter无法自增，解决的办法就是在其失效之前完成自增）的方式删除迭代器
map是关联式容器，以红黑树或者平衡二叉树组织数据，虽然删除了一个元素，整棵树也会调整，以符合二叉树或者红黑树的规范，但是单个节点的改变必然会调整树的结构，其中单个节点在内存中的地址没有变化且各个节点的指向关系。另外一种保险和比较易读的写法是写一个临时迭代器保存当前迭代器，之后迭代器本身自增，在erase临时的

WangJ_F_

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
C++ Vector（向量容器）：特点，使用方式及迭代器失效问题

目录vector介绍vector特点vector初始化vector iterator的使用vector空间增长问题vector增删查改vector迭代器失效问题迭代器失效总结vector介绍vector是一个线性顺序结构。相当于数组，但其大小可以不预先指定，并且自动扩展。它可以像数组一样被操作，由于它的特性我们完全可以将vector看作动态数组。...
复制链接

扫一扫