vetor和array类似，都是普通数组的“升级版”，但array实现的时静态数组（长度固定），而vector实现的时一个动态数组，即可以进行元素的插入和删除。

一、调用方法

  1. #include <vector>
  2. using namespace std;

二、vector支持的迭代器的成员函数

image.png

C++ 11 新添加的 begin() 和 end() 全局函数也同样适用于 vector 容器。即当操作对象为 vector 容器时，其功能分别和表 1 中的 begin()、end() 成员函数相同。

迭代器的具体功能示意图
image.png

vector使用中的问题

容量(capacity)和大小(size)的区别

image.png

  • size返回当前实际的元素个数，即vector的大小，
  • capacity返回容量大小，可以通过reserce修改
  • vector 容器的大小不能超出它的容量，在大小等于容量的基础上，只要增加一个元素，就必须分配更多的内存。注意，这里的“更多”并不是 1 个。换句话说，当 vector 容器的大小和容量相等时，如果再向其添加（或者插入）一个元素，vector 往往会申请多个存储空间，而不仅仅只申请 1 个
  • 一旦 vector 容器的内存被重新分配，则和 vector 容器中元素相关的所有引用、指针以及迭代器，都可能会失效，最稳妥的方法就是重新生成

    emplace_back()和push_back()的区别

    emplace_back() 和 push_back() 的区别，就在于底层实现的机制不同。push_back() 向容器尾部添加元素时，首先会创建这个元素，然后再将这个元素拷贝或者移动到容器中（如果是拷贝的话，事后会自行销毁先前创建的这个元素）；而 emplace_back() 在实现时，则是直接在容器尾部创建这个元素，省去了拷贝或移动元素的过程

    insert()成员函数的语法格式

    image.png

    删除元素的几种方式

    image.png

    三、代码中的使用

    ```cpp

    include

    include

    include

    include

using namespace std;

int main() { /创建并初始化vector容器 / //1、创建空的vector，vt.size()==0 vector vt;

  1. //2、指定初始值和元素个数
  2. vector<int> primes{1, 2, 3, 4};
  4. //3、创建含有20个元素的vector,默认初始值都是0
  5. vector<int> pri1(20);
  6. vector<int> pri2(10, 5); //创建含有10个元素的vector,初始值都是5
  7. int a = 5, b = 10;
  8. vector<int> pri3(a, b); //两个个参数也可以通过变量来指定初始值
  10. //4、通过元素类型相同的vector来初始化
  11. vector<char> value1(5, 'c');
  12. vector<char> value2(value1); //value1和value2一样，都是具有5个元素，且初始值都是'c'
  13. int arr[] = {1, 2, 3};
  14. vector<int> value3(arr, arr+2); //value3将保存{1,2}
  15. vector<int> value4{1, 2, 3, 4, 5};
  16. vector<int> value5(value4.begin(), value4.begin()+3); //value5保存{1,2,3}
  17. /************************************************************/
  20. /*在容器中插入元素*/
  21. vector<int> vt1;
  22. //1、在尾部插入一个元素
  23. vt1.push_back(1);
  25. //2、在尾部插入一个元素,C++11新增成员函数，比push_back效率高
  26. vt1.emplace_back(3);
  28. //3、在头部插入一个元素
  29. vt1.insert(vt1.begin(), 2);
  31. //4、inset成员函数，插入多个元素
  32. //4-1 iterator insert(pos,elem)
  33. //在迭代器 pos 指定的位置之前插入一个新元素elem，并返回表示新插入元素位置的迭代器
  34. vector<int> iv{1, 2};
  35. iv.insert(iv.begin(), 8); //{1, 8, 2}
  36. //4-2 iterator insert(pos,n,elem)
  37. //在迭代器 pos 指定的位置之前插入 n 个元素 elem，并返回表示第一个新插入元素位置的迭代器
  38. iv.insert(iv.end(), 2, 5); //{1, 8, 2, 5, 5}
  39. //4-3 iterator insert(pos,first,last)
  40. //在迭代器 pos 指定的位置之前，插入其他容器（不仅限于vector）中位于 [first,last) 区域的所有元素，并返回表示第一个新插入元素位置的迭代器
  41. array<int, 3> arr0{7, 8, 9};
  42. iv.insert(iv.end(), arr0.begin(), arr0.end()); //{1, 8, 2, 5, 5, 7, 8, 9}
  43. //4-4 iterator insert(pos,initlist)
  44. //在迭代器 pos 指定的位置之前，插入初始化列表（用大括号{}括起来的多个元素，中间有逗号隔开）中所有的元素，并返回表示第一个新插入元素位置的迭代器
  45. iv.insert(iv.end(), {1, 2}); //{1, 8, 2, 5, 5, 7, 8, 9, 1, 2}
  47. //5、emplace成员函数
  48. //iterator emplace (const_iterator pos, args...);
  49. //emplace() 是 C++ 11 标准新增加的成员函数，用于在 vector 容器指定位置之前插入一个新的元素
  50. //emplace效率高于inset
  51. //强调，emplace() 每次只能插入一个元素，而不是多个
  52. vector<int> demo{1, 2};
  53. demo.emplace(demo.begin(), 3); //{3,1,2}
  54. /**********************************************/
  57. /*迭代器的用法*/
  58. //1、 begin() 和 end() 成员函数
  59. vector<int> val{1, 2, 3, 4, 5};
  60. auto first = val.begin();
  61. auto end = val.end();
  62. while (first != end)
  63. {
  64.     cout<<*first<<" ";
  65.     first++;
  66. }
  67. cout<<endl;
  69. //2、begin() 和 end() 函数
  70. auto first1 = begin(val);
  71. auto end1 = std::end(val);
  73. //3、cbegin()/cend() 成员函数
  74. //和 begin()/end() 唯一不同的是，前者返回的是 const 类型的正向迭代器
  75. vector<int> cval{1, 2, 3, 4, 5};
  76. auto cfirst = cval.cbegin();
  77. auto cend = cval.cend();
  78. while (cfirst != cend)
  79. {
  80.     //*cfirst = 10; 不能修改元素
  81.     cout<<*cfirst<<" ";
  82. }
  83. cout<<endl;
  85. //4、rbegin() 和 rend() 成员函数
  86. //分别表示指向最后一个元素和第一个元素前一个位置的随机访问迭代器
  87. vector<int> rval{1, 2, 3, 4, 5};
  88. auto rfirst = rval.rbegin();
  89. auto rend = rval.rend();
  90. while (rfirst != rend)
  91. {
  92.     cout<<*rfirst<<" ";
  93.     rfirst++;
  94. }
  96. //5、crbegin()/crend()成员函数
  97. //和 rbegin()/crend() 组合唯一的区别在于，前者返回的迭代器为 const 类型
  99. //6、对于空的 vector 容器来说，begin() 和 end() 成员函数返回的迭代器是相等的，即它们指向的是同一个位置
  100. //对于空的 vector 容器来说，可以通过调用 push_back() 或者借助 resize() 成员函数实现初始化容器的目的
  102. //7、vector 容器在申请更多内存的同时，容器中的所有元素可能会被复制或移动到新的内存地址，这会导致之前创建的迭代器失效
  103. vector<int> vv{1, 2, 3};
  104. cout<<"vv容器首个元素的地址: "<<vv.data()<<endl;
  105. auto vfirst = vv.begin();
  106. auto vend = vv.end();
  107. vv.reserve(10);
  108. cout<<"vv容器首个元素的地址: "<<vv.data()<<endl;
  109. /*********************************************************/
  112. /*删除元素*/
  113. //1、pop_back()
  114. //删除 vector 容器中最后一个元素，该容器的大小（size）会减 1，但容量（capacity）不会发生改变
  115. vector<int> vdel{1, 2, 3};
  116. vdel.pop_back();
  117. cout<<vdel.capacity()<<endl; //容量大小不变
  118. cout<<vdel.size()<<endl;//元素个数减一
  119. for (int k=0; k<vdel.size(); k++)
  120.     cout<<vdel[k];
  121. //{1, 2}
  123. //2、erase(pos)
  124. //删除 vector 容器中 pos 迭代器指定位置处的元素，并返回指向被删除元素下一个位置元素的迭代器。该容器的大小（size）会减 1，但容量（capacity）不会发生改变
  125. vector<int> vdel1{1,2,3,4,5};
  126. auto itor = vdel1.erase(vdel1.begin()+1);
  127. cout<<vdel1.size()<<endl; //元素个数减一
  128. cout<<vdel1.capacity()<<endl; //容量大小不变
  129. cout<<*itor<<endl; //迭代器itor指向3的位置
  131. //3、swap(beg)、pop_back()
  132. //先调用 swap() 函数交换要删除的目标元素和容器最后一个元素的位置，然后使用 pop_back() 删除该目标元素
  133. //swap() 函数在头文件 <algorithm> 和 <utility> 中都有定义，使用时引入其中一个即可
  134. vector<int> vdel2{1,2,3,4,5};
  135. //3-1交换要删除元素和最后一个元素的位置
  136. swap(*(std::begin(vdel2)+1),*(std::end(vdel2)-1)); //等同于swap(vdel2[1],vdel2[4])
  137. //删除最后一个元素
  138. vdel2.pop_back();
  140. //4、删除容器中某个指定区域内的所有元素
  141. //iterator erase (iterator first, iterator last);
  142. //first 和 last 是指定被删除元素区域的迭代器，同时该函数会返回指向此区域之后一个位置的迭代器
  143. vector<int> vdel4{1,2,3,4,5};
  144. //删除2，3
  145. vdel4.erase(vdel4.begin()+1, vdel4.end()-2);
  146. cout<<vdel4.size()<<endl; //元素个数减2
  147. cout<<vdel4.capacity()<<endl; //容量大小不变
  149. //5、remove() 函数
  150. //删除容器中和指定元素值相同的所有元素
  151. vector<int> vdel5{1,2,3,4,3,5};
  152. auto iter = remove(vdel5.begin(), vdel5.end(), 3);
  153. cout<<vdel5.size()<<endl; //6
  154. cout<<vdel5.capacity()<<endl; //6
  155. vdel5.erase(iter, vdel5.end());
  156. cout<<vdel5.size()<<endl; //4
  157. cout<<vdel5.capacity()<<endl; //6
  158. //remove() 的实现原理是，在遍历容器中的元素时，一旦遇到目标元素，就做上标记，然后继续遍历，直到找到一个非目标元素，即用此元素将最先做标记的位置覆盖掉，同时将此非目标元素所在的位置也做上标记，等待找到新的非目标元素将其覆盖。因此，如果将上面程序中 demo 容器的元素全部输出
  160. //6、clear成员函数
  161. //删除容器中所有的元素
  162. vector<int> vdel6{1,2,3};
  163. vdel6.clear();
  164. cout<<vdel6.size()<<endl; //0
  165. cout<<vdel6.capacity()<<endl; //3
  166. /**********************************************/
  168. /*访问元素*/
  169. vector<int> vtt{1, 2, 3, 4, 5};
  170. //1、下标访问,跟数组访问方法一样
  171. cout<<vtt[0]<<endl;
  173. //2、at() 成员函数
  174. //索引会造成越界时，会抛出std::out_of_range异常
  175. cout<<vtt.at(0)<<endl;
  177. //3、front() 和 back()成员函数
  178. //分别返回 vector 容器中第一个和最后一个元素的引用
  179. vtt.front() = 10; //修改元素
  180. cout<<vtt.front()<<endl;
  181. cout<<vtt.back()<<endl;
  183. //4、data() 成员函数
  184. //返回指向容器中首个元素的指针
  185. *(vtt.data()+2) = 19;
  186. cout<<*(vtt.data()+2)<<endl;
  188. //5、访问vector容器中多个元素
  189. //借助 size() 成员函数,返回 vector 容器中实际存储的元素个数
  190. for (int i=0; i<vtt.size(); i++)
  191. {
  192.     cout<<vtt[i]<<endl;
  193. }
  194. /********************************************/
  197. /*容量(capacity)和大小(size)的区别*/
  198. //vector 容器的容量（用 capacity 表示），指的是在不分配更多内存的情况下，容器可以保存的最多元素个数；
  199. //容器的大小（用 size 表示），指的是它实际所包含的元素个数
  200. //对于一个 vector 对象来说，通过该模板类提供的 capacity() 成员函数，可以获得当前容器的容量；通过 size() 成员函数，可以获得容器当前的大小
  201. vector<int> v{1, 2, 3, 4, 5};
  202. v.reserve(20); //修改v的容量大小
  203. cout<<v.capacity()<<endl; //容量大小是 20
  204. cout<<v.size()<<endl; //元素个数大小 5
  205. /************************************************/
  208. cout<<primes.size()<<endl;
  210. cout << "Hello World!" << endl;
  211. return 0;

}

```