vector容器详解
- 一.vector容器简单介绍
- 二.vector的构造函数
- 三.vector中与容量和大小相关操作
- 3.1接口函数说明
- 3.2使用时的性能优化
- 四.vector中的元素访问与修改
- 五.vector迭代器与遍历
- 5.1迭代器
- 5.2迭代器失效问题
- 5.2.1 扩容导致的迭代器失效问题
- 5.2.2删除导致的迭代器失效问题
一.vector容器简单介绍
- vector是表示可变大小数组的序列容器。
- 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
- 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
- vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
- 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
- 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好.
与传统C语言风格的数组相比,vector支持自动扩容,而且C语言数组对于越界访问的检查是一种抽查机制,有可能检查不出来的,而vector中是以assert的方式暴力检查,只要访问就报错.更加的安全
vector的优缺点:
1.优点:vector是一种顺序表,它随机访问效率高.
2.缺点:vector在尾部插入删除还可以,但是在头部插入删除需要挪动后面的数据,时间复杂度为O(N),效率相对较低.
因此,一般而言,链表(list)和顺序表(vector)是相辅相成的两种数据结构,它们优缺点正好相反,如果需要随机访问速度快就使用vector,需要插入删除效率高就用list.
二.vector的构造函数
STL库中依旧提供了多种重载函数用来构造一个vector对象.
| 函数名称 | 功能说明 |
|---|---|
| vector()(重点) | 无参构造 |
| vector（size_type n, const value_type& val = value_type()） | 构造并初始化成n个val |
| vector (const vector& x); （重点） | 拷贝构造 |
| vector (InputIterator first, InputIterator last);(也挺好用) | 迭代器区间初始化 |
| vector (initializer_list<value_type> il) | C++11之后支持用initializer_list来初始化 |
这里还要注意:vector是一个类模板,创建对象时需要显示实例化,
例如:vector<T>
代码示例:
int main()
{
//默认构造
vector<int> v1;
//n个val构造
vector<int> v2(10, 1);
//拷贝构造
vector<int> v3(v2); //也可以写成vector<int> v3 = v2;
//迭代器区间初始化
int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
vector<int> v4(a, a + 10);
//initializer_list初始化
initializer_list<int> il = { 0,1,2,3,4,5,6,7,8,9 };
vector<int> v5(il); //也可以写成 vector<int> v5({ 0,1,2,3,4,5,6,7,8,9 });或者vector<int> v5{ 0,1,2,3,4,5,6,7,8,9 };
cout << "默认构造:";
for (const auto& e : v1)
{
cout << e << " ";
}
cout << endl;
cout << "n个val构造:";
for (const auto& e : v2)
{
cout << e << " ";
}
cout << endl;
cout << "拷贝构造:";
for (const auto& e : v3)
{
cout << e << " ";
}
cout << endl;
cout << "迭代器区间初始化:";
for (const auto& e : v4)
{
cout << e << " ";
}
cout << endl;
cout << "initializer_list初始化:";
for (const auto& e : v5)
{
cout << e << " ";
}
cout << endl;
return 0;
}
输出结果:
默认构造:
n个val构造:1 1 1 1 1 1 1 1 1 1
拷贝构造:1 1 1 1 1 1 1 1 1 1
迭代器区间初始化:0 1 2 3 4 5 6 7 8 9
initializer_list初始化:0 1 2 3 4 5 6 7 8 9
如果有需要的小伙伴可以去官方文档再查看一下:vector
三.vector中与容量和大小相关操作
3.1接口函数说明
| 函数名称 | 功能说明 |
|---|---|
| size() | 获取数据个数 |
| capacity() | 获取容量大小 |
| empty() | 判断是否为空 |
| resize()(重点) | 改变vector的 |
| reserve()(重点) | 改变vector的capacity |
| shrink_to_fit | 收缩capacity使其适应size |
代码示例:
int main()
{
vector<int> v1{1,2, 3, 4, 5, 6, 7, 8, 9};
cout << "size:" << v1.size()<<endl;
cout << "capacity:" << v1.capacity() << endl;
v1.resize(20);
cout << "resize后:" << v1.size() << endl;
cout << "capacity:" << v1.capacity() << endl;
v1.reserve(100);
cout << "size:" << v1.size() << endl;
cout << "reserve:" << v1.capacity() << endl;
v1.shrink_to_fit();
cout << "size:" << v1.size() << endl;
cout << "shrink_to_fit:" << v1.capacity() << endl;
return 0;
}
输出结果:
size:9
capacity:9
resize后:20
capacity:20
size:20
reserve:100
size:20
shrink_to_fit:20
3.2使用时的性能优化
当vector容量满之后再插入数据,就会自动扩容,通常的过程是申请一块更大的空间,将数据拷贝过去之后,释放旧空间.如果频繁扩容,在效率上会比较低下.
因此我们如果知道共有多少个数据,就可以resize提前开好足够的空间,避免频繁扩容.
四.vector中的元素访问与修改
1.元素访问方法:
| 元素访问方法 | 功能说明 |
|---|---|
| operator[] | 通过下标访问vector,内部通过assert对下标进行了严格检查 |
| at() | 也是通过下标访问,内部通过抛出异常来报错 |
| front() | 返回第一个元素 |
| back() | 返回最后一个元素 |
| data() | 返回指向数组首元素的指针 |
代码示例:
int main()
{
vector<int> v1{ 1,2,3,4,5,6,7,8,9 };
for (size_t i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
try {
cout << v1.at(10); // 越界访问
}
catch (out_of_range& e)
{
cout << "Exception: " << e.what() << endl;
}//异常捕获
cout << "front:" << v1.front() << endl;
cout << "back:" << v1.back() << endl;
return 0;
}
输出结果:
1 2 3 4 5 6 7 8 9
Exception: invalid vector subscript
front:1
back:9
2.元素修改方法
可以通过operator[]和at来直接进行修改.
这两个函数的返回值是引用,因此直接通过返回值修改数据即可.
五.vector迭代器与遍历
5.1迭代器
vector中有许多类型的迭代器,便于我们遍历与访问元素.
| 迭代器 | 功能说明 |
|---|---|
| begin() | 返回指向第一个元素的迭代器 |
| end() | 返回指向最后元素的下一个位置的迭代器 |
| rbegin() | 返回指向最后一个元素的反向迭代器 |
| rend() | 返回指向第一个元素的前一个位置的迭代器 |
代码示例:
int main()
{
vector<int> v1{ 1,2,3,4,5,6,7,8,9 };
//正向迭代器遍历
vector<int>::iterator it = v1.begin();
while (it != v1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
//反向迭代器遍历
vector<int>::reverse_iterator rit = v1.rbegin();
while (rit != v1.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
return 0;
}
输出结果:
1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1
5.2迭代器失效问题
迭代器失效问题的本质:就是迭代器指向的空间被销毁了或者不指向有效的数据了,这时失效的迭代器就类似于野指针一样,如果再用它来访问元素,就会导致程序崩溃.
对于vector可能会导致其迭代器失效的操作有：
1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。
2. 指定位置元素的删除操作–erase.
5.2.1 扩容导致的迭代器失效问题
为了引出这个问题,我们接下来看一段代码.
代码示例:
int main()
{
vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
// v.resize(100, 8);
// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
// v.reserve(100);
// 插入元素期间，可能会引起扩容，而导致原空间被释放
// v.insert(v.begin(), 0);
// v.push_back(8);
// 给vector重新赋值，可能会引起底层容量改变
v.assign(100, 8);
/*
出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
*/
while(it != v.end())
{
cout<< *it << " " ;
++it;
}
cout<<endl;
return 0;
}
观察文档,我们会发现,通过迭代器来确定位置的insert重载函数,都会返回一个迭代器,这个迭代器是指向新插入的第一个元素的迭代器。
因此,我们在使用insert插入是时要及时更新迭代器!!!
代码示例:
int main()
{
vector<int> v1{ 1,2,3 };
auto it = v1.begin()+2;
cout << *it << endl;
//更新失效的迭代器
it = v1.insert(it, 4);
cout << *it << endl;
return 0;
}
输出结果:
3
4
5.2.2删除导致的迭代器失效问题
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。
以下代码的功能是删除vector中所有的偶数.
int main()
{
vector<int> v{ 1, 2, 3, 4 };
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
it = v.erase(it);
else
++it;
}
return 0;
}
还是要注意更新迭代器!
希望对你有所帮助,感谢观看!
