• vector的介绍以及使用方式

    目录

    前言

    1.vector的介绍

    2.构造函数

    3.迭代器

    4.vector空间增长问题

    5.vector的增删改查

    6.vector迭代器失效问题

    总结

    前言

    即我们的string之后，今天小编给大家要介绍一个我们stl中另外一个常用的容器vector，和我们的string一样我们的vector底层的存储结构是我们的顺序表，但是与之不同的我们的string只是支持我们字符串类型的存储，而我们的vector作为一个通用的容器该是支持各个类型的，而这个也就是需要靠我们之前学习的模板实现，那么接下来我们就开始展开对我们的vector的学习吧。（注意：这里小编只介绍我们常用的接口）

    1.vector的介绍

    1. vector是表示可变大小数组的序列容器。

    2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

    3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。

    4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。

    5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。

    6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。

      在介绍我们vector接口使用前，我们先看一下我们，vector的模板参数。                                  对于vector的模板参数，T指的是对模板参数进行实例化的类型而这里的allocator就是一个空间配置器，也就是内存池，为了提高内存效率 。

    2.构造函数

    这里的接口很多使用方式都是和我们的string都是类似的，但是对于我们的迭代器初始化，我们并没有接触过，这里我给大家看看该具体的样子：

    对于迭代器的初始化这里的InputIterator指的是一个模板类型，所以这里的迭代器可以是各个类型的。

    测试代码：

    1. #include
    2. #include//使用记得包文件
    3. using namespace std;
    4. int main()
    5. {
    6. 	//需实例化模板
    7. 	//无参构造
    8. 	vector<int> v1();
    9. 	//构造并初始化n个val
    10. 	vector<int> v2(10, 1);
    11. 	//拷贝构造
    12. 	vector<int> v3(v2);
    13. 	//迭代器构造
    14. 	int a[] = { 10,9,8,7,6,5,4,3,2,1 };
    15. 	vector<int>v4(a, a + 10);
    16. 	return 0;
    17. }

    这里大家可以看到我们迭代器版本初始化时使用了我们的数组进行初始化，这是由于数组我们可以看做是一个天然的迭代器，自然我们可以使用我们的数组首地址和首地址+某个值进行初始vector。

    这里由于我们的vector没有我们的流提取操作符的重载，因此这里我们给大家打开我们的监视窗口，来看一下我们底层的存储情况。

    3.迭代器

    这里给大家简单看看一下我们正向迭代器begin（）和end（）的指向，以及我们正向迭代器和我们反向迭代器的对应关系：

    测试代码：

    1. #include
    2. #include//使用记得包文件
    3. using namespace std;
    4. int main()
    5. {
    6. 	int a[] = { 10,9,8,7,6,5,4,3,2,1 };
    7. 	vector<int> v1(a, a + 10);
    8. 	//范围for验证
    9. 	for (auto& e : v1)
    10. 	{
    11. 		cout << e << " ";
    12. 	}
    13. 	cout << endl;
    14. 	//正向迭代器验证
    15. 	vector<int>::iterator it = v1.begin();
    16. 	while (it != v1.end())
    17. 	{
    18. 		cout << *it << " ";
    19. 		it++;
    20. 	}
    21. 	cout << endl;
    22. 	//反向迭代器验证
    23. 	vector<int>::reverse_iterator it1 = v1.rbegin();
    24. 	while (it1 != v1.rend())
    25. 	{
    26. 		cout << *it1 << " ";
    27. 		it1++;
    28. 	}
    29. 	return 0;
    30. }

    结果如下：

    4.vector空间增长问题

    capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。

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

    对于我们vs和我们g++空间增长机制，这里我们使用一串代码给大家验证一下：

    1. void text_space_expand()
    2. {
    3. 	size_t cp = 0;
    4. 	vector<int> v1;
    5. 	cp = v1.capacity();
    6. 	for (int i = 0; i < 1000; i++)
    7. 	{
    8. 		v1.push_back(i);
    9. 		if (cp != v1.capacity())
    10. 		{
    11. 			cp = v1.capacity();
    12. 			cout << "capacity changed:" << cp << endl;
    13. 		}
    14. 	}
    15.  
    16. }

    vs平台下运行结果：

    g++运行结果：

    这里大家就可以清楚的看到，我们的capacityvs下是按1.5倍增长的，g++是按2倍增长的。

    那么这里就简单的给大家演示一下这几个接口的用法：

    1. #include
    2. #include//使用记得包文件
    3. using namespace std;
    4. int main()
    5. {
    6. 	vector<int> v1(10, 1);
    7. 	cout << "有效数据个数:" << v1.size()<
    8. 	cout << "空间大小:" << v1.capacity() << endl;
    9. 	cout << "是否为空:" << v1.empty() << endl;
    10.  
    11. 	v1.clear();
    12. 	cout << "有效数据个数:" << v1.size() << endl;
    13. 	cout << "空间大小:" << v1.capacity() << endl;
    14. 	cout << "是否为空:" << v1.empty() << endl;
    15.  
    16. 	v1.resize(9, 1);
    17. 	v1.reserve(100);
    18. 	cout << "有效数据个数:" << v1.size() << endl;
    19. 	cout << "空间大小:" << v1.capacity() << endl;
    20. 	cout << "是否为空:" << v1.empty() << endl;
    21. 	return 0;
    22. }

    结果如下：

    5.vector的增删改查

    我们的vector本身并没有是实现我们的find，我们这里的find时属于算法模块的，也就是

    这里我们的调用方式是，传入一个迭代器区间，然后在这个区间内查找我们的val，这里返回的也是这个值的迭代器。

    对于我们的insert这里一共有三个版本：

    第一个是在我们pos迭代器位置前插入val，一个是在pos迭代器位置前插入n个val，第三个是在pos位置前插入一段迭代器区间(不过由于效率问题，我们这里并不经常使用)

    对于erase我们这里也有两个版本：

    第一个是删除pos迭代器的值，一个是删除一段迭代器区间，注意这里返回值是我们的迭代器，这里和我们的迭代器失效有关

    测试代码如下：

    1. #include
    2. #include//使用记得包文件
    3. #include//算法库头文件
    4. using namespace std;
    5. int main()
    6. {
    7. 	vector<int> v1;
    8. 	//尾插
    9. 	v1.push_back(1);
    10. 	v1.push_back(2);
    11. 	v1.push_back(3);
    12. 	v1.push_back(4);
    13. 	v1.push_back(5);
    14. 	//方括号读取修改数据
    15. 	for (int i = 0; i < v1.size(); i++)
    16. 	{
    17. 		v1[i]++;
    18. 		cout << v1[i] << " ";
    19. 	}
    20. 	cout << endl;
    21. 	//尾删
    22. 	v1.pop_back();
    23. 	for (auto& e : v1)
    24. 	{
    25. 		cout << e << " ";
    26. 	}
    27. 	cout << endl;
    28. 	//查找
    29. 	auto it = find(v1.begin(), v1.end(), 4);
    30. 	cout << *it << endl;
    31. 	//删除具体某个值
    32. 	v1.erase(it);
    33. 	for (auto& e : v1)
    34. 	{
    35. 		cout << e << " ";
    36. 	}
    37. 	cout << endl;
    38. 	//在某个具体位置插入
    39. 	v1.insert(v1.begin() + 2, 20);
    40. 	v1.insert(v1.begin() + 2,4, 10);
    41. 	for (auto& e : v1)
    42. 	{
    43. 		cout << e << " ";
    44. 	}
    45. 	cout << endl;
    46. 	vector<int> v2(10,1);
    47. 	cout << "交换前v1的值:";
    48. 	for (auto& e : v1)
    49. 	{
    50. 		cout << e << " ";
    51. 	}
    52. 	cout << endl;
    53. 	cout << "交换前v2的值:";
    54. 	for (auto& e : v2)
    55. 	{
    56. 		cout << e << " ";
    57. 	}
    58. 	cout << endl;
    59. 	v1.swap(v2);
    60. 	cout << "交换后v1的值:";
    61. 	for (auto& e : v1)
    62. 	{
    63. 		cout << e << " ";
    64. 	}
    65. 	cout << endl;
    66. 	cout << "交换后v2的值:";
    67. 	for (auto& e : v2)
    68. 	{
    69. 		cout << e << " ";
    70. 	}
    71. 	cout << endl;
    72. 	return 0;
    73. }

    结果如下：

    6.vector迭代器失效问题

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

    那么对于vector可能会导致其迭代器失效的操作有：

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

    1. #include 
    2. using namespace std;
    3. #include 
    4. int main()
    5. {
    6. vector<int> v{1,2,3,4,5,6};
    7. auto it = v.begin();
    8. // 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
    9.  v.resize(100, 8);
    10. // reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
    11.  v.reserve(100);
    12. // 插入元素期间，可能会引起扩容，而导致原空间被释放
    13.  v.insert(v.begin(), 0);
    14.  v.push_back(8);
    15. // 给vector重新赋值，可能会引起底层容量改变
    16. v.assign(100, 8);
    17. /*
    18. 出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
    19. 而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
    20. 空间，而引起代码运行时崩溃。
    21. 解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
    22. 赋值即可，也就是让我们的it重新指向新空间
    23. */
    24. while(it != v.end())
    25. {
    26. cout<< *it << " " ;
    27. ++it;
    28. }
    29. cout<
    30. return 0;
    31. }

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

    1. #include 
    2. using namespace std;
    3. #include 
    4. int main()
    5. {
    6. int a[] = { 1, 2, 3, 4 };
    7. vector<int> v(a, a + sizeof(a) / sizeof(int));
    8. // 使用find查找3所在位置的iterator
    9. vector<int>::iterator pos = find(v.begin(), v.end(), 3);
    10. // 删除pos位置的数据，导致pos迭代器失效。
    11. v.erase(pos);
    12. cout << *pos << endl; // 此处会导致非法访问
    13. return 0;
    14. }

    erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

    既然我们erase的存在着迭代器失效的问题，那么我们库中是如何解决此类问题的呢？

    首先需要注意我们erase的返回值就是我们删除后下一个位置的迭代器，因此重新接收后，就不会导致我们的迭代器失效。

    以下代码的功能是删除vector中所有的偶数，请问那个代码是正确的，为什么？

    1. #include 
    2. using namespace std;
    3. #include 
    4. //程序一
    5. int main()
    6. {
    7. vector<int> v{ 1, 2, 3, 4 };
    8. auto it = v.begin();
    9. while (it != v.end())
    10. {
    11. if (*it % 2 == 0)
    12. v.erase(it);
    13. ++it;
    14. }
    15. return 0;
    16. }
    17. //程序二
    18. int main()
    19. {
    20. vector<int> v{ 1, 2, 3, 4 };
    21. auto it = v.begin();
    22. while (it != v.end())
    23. {
    24. if(*it % 2 == 0)
    25. it = v.erase(it);
    26. else
    27. ++it;
    28. }
    29. return 0;
    30. }

    首先通过我们上面的讲解，我们的程序二很明显是错误，那么我们程序一在能运行的情况下，该是否会发生迭代器失效呢？这里我给大家分析一下：

    对于程序二，我们每次删除后都会接受erase删除下一个值，不会出现迭代器失效的情况。

    3. 注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

    实际上我们的在删除偶数时，我们程序一的代码在vs下是不能运行的，因为vs对这个进行的是强制检查，无论我们的删除后我们的迭代器指向那里都会崩溃，只有重新接收后才不会影响程序运行

    这里就给大家举例几个g++下的例子：

    例一：

    1. // 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
    2. int main()
    3. {
    4. vector<int> v{1,2,3,4,5};
    5. for(size_t i = 0; i < v.size(); ++i)
    6. cout << v[i] << " ";
    7. cout << endl;
    8. auto it = v.begin();
    9. cout << "扩容之前，vector的容量为: " << v.capacity() << endl;
    10. // 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效
    11. v.reserve(100);
    12. cout << "扩容之后，vector的容量为: " << v.capacity() << endl;
    13. // 经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux下不会
    14. // 虽然可能运行，但是输出的结果是不对的
    15. while(it != v.end())
    16. {
    17. cout << *it << " ";
    18. ++it;
    19. }
    20. cout << endl;
    21. return 0;
    22. }

    运行结果：

    程序输出：1 2 3 4 5
    扩容之前，vector的容量为: 5
    扩容之后，vector的容量为: 100
    0 2 3 4 5 409 1 2 3 4 5

    这里很明显可以看出我们迭代器访问旧空间的值出现的是随机的。

    例二：

    1. // 2. erase删除任意位置代码后，linux下迭代器并没有失效
    2. // 因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的
    3. #include 
    4. #include 
    5. int main()
    6. {
    7. vector<int> v{1,2,3,4,5};
    8. vector<int>::iterator it = find(v.begin(), v.end(), 3);
    9. v.erase(it)
    10. cout << *it << endl;
    11. while(it != v.end())
    12. {
    13. cout << *it << " ";
    14. ++it;
    15. }
    16. cout << endl;
    17. return 0;
    18. }

    运行结果：

    程序可以正常运行，并打印：
    4
    4 5

    这里我们看到例二是正常的，那么我们看下面一个例子

    例三（就是之前的删除偶数的程序一）：

    1. // 3: erase删除的迭代器如果是最后一个元素，删除之后it已经超过end
    2. // 此时迭代器是无效的，++it导致程序崩溃
    3. int main()
    4. {
    5. vector<int> v{1,2,3,4,5};
    6. // vector v{1,2,3,4,5,6};
    7. auto it = v.begin();
    8. while(it != v.end())
    9. {
    10. if(*it % 2 == 0)
    11. v.erase(it);
    12. ++it;
    13. }
    14. for(auto e : v)
    15. cout << e << " ";
    16. cout << endl;
    17. return 0;
    18. }

    对于例子三我们这里提供了两个版本的数据，一个是要删除最后一个元素，一个是不用删除最后一个元素，那么两组数据运行的结果是：

    数据一：

    运行正常，打印结果为：

    1 3 5

    数据二：

    程序崩溃：

    Segmentation fault

    4.与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效

    1. #include 
    2. void TestString()
    3. {
    4. string s("hello");
    5. auto it = s.begin();
    6. // 放开之后代码会崩溃，因为resize到20会string会进行扩容
    7. // 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
    8. // 后序打印时，再访问it指向的空间程序就会崩溃
    9. //s.resize(20, '!');
    10. while (it != s.end())
    11. {
    12. cout << *it;
    13. ++it;
    14. }
    15. cout << endl;
    16. it = s.begin();
    17. while (it != s.end())
    18. {
    19. it = s.erase(it);
    20. // 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
    21. // it位置的迭代器就失效了
    22. // s.erase(it);
    23. ++it;
    24. }
    25. }

    对于迭代器失效问题，这是我们在平时使用过程中需要注意的，解决方式就是在失效后，我们需要重新赋值就可以解决了。

    总结

    对于vector常用接口的介绍，基本已经到这里了，其他的接口就需要靠大家查阅文档，或者使用中去不断学习。

  • 相关阅读:
    Two-stage RO: part 1
    封装localStorage，支持切换存储引擎 sessionStorage，支持vue hook方式调用
    SpringBoot-15-模块开发-页面国际化
    Oracle SQL执行计划操作（6）——并行相关操作
    foolgo解析—ChainSet类笔记
    Android 获取短信验证
    KWin、libdrm、DRM从上到下全过程 —— drmModeAddFBxxx（3）
    安装ubuntu 18
    [补题记录] Atcoder Beginner Contest 325（E、F）
    《代码随想录》三刷，与诸君共勉，秋招见！
  • 原文地址：https://blog.csdn.net/weixin_68624665/article/details/133583052