C++ STL之vector用法总结

总结一下平时常用的vector的用法。

• 初始化

  int a[3] = {10, 20, 30};
  vector<int> v1; //{}
  vector<int> v2(3); //{0, 0, 0}
  vector<int> v3 {1, 2, 3, 4, 5}; //vector<int> v3 = {1, 2, 3, 4, 5};
  vector<int> v4(3,10); //{10, 10, 10}
  vector<int> v5 = v3; //vector<int> v5(v3);
  vector<int> v6(v3.begin()+1, v3.end()); //vector<int> v6(&a[0], &a[3]);

• 二维数组初始化

  //{{}}
  vector<vector<int>> vec1;
  //1 1 1
  //1 1 1
  vector<vector<int>> vec2(2, vector<int>(3,1));
  //1 1 1
  //2 3 4
  vector<vector<int>> vec3 = {{1, 1, 1},{2, 3, 4}};

• 遍历

  for(int i = 0; i < v3.size(); ++i){
      cout << v3[i] << " ";
  }
  for(vector<int>::iterator it = v3.begin(); it != v3.end(); it++){
      cout << *it << " ";
  }
  for(auto i:v3){
      cout << i << " ";
  }

• 逆序遍历

  for (auto it = v5.rbegin(); it != v5.rend(); it++){
      cout << *it << " ";
  }

• 容器长度

  v3.size();

• 获取容器第一个元素，最后一个元素

  v3.front();
  v3.back();

• 判断为空，1为空，0非空

  v3.empty();

• 尾插/弹出

  //v1{}
  v1.push_back(1); //{1}
  v1.push_back(2); //{1, 2}
  v1.push_back(3); //{1, 2, 3}
  v1.pop_back(); //{1, 2}
  v1.pop_back(); //{1}
  v1.pop_back(); //{}

• 插入

  //v3{1, 2, 3, 4, 5}
  v3.insert(v3.begin()+1, 0); //{1, 2, 3, 4, 5}->{1, 0, 2, 3, 4, 5}
  v3.insert(v3.end(), 0); //{1, 0, 2, 3, 4, 5}->{1, 0, 2, 3, 4, 5, 0}
  v3.insert(v3.begin(), v4.begin(), v4.end()); //{1, 0, 2, 3, 4, 5, 0}->{10, 10, 10, 1, 0, 2, 3, 4, 5, 0}

• 合并

  //v2{0, 0, 0} v4{10, 10, 10}
  v2.insert(v2.end(), v4.begin(), v4.end());//{0, 0, 0}->{0, 0, 0, 10, 10, 10}

• 删除

  v3.erase(v3.begin()+4); //{10, 10, 10, 1, 0, 2, 3, 4, 5, 0}->{10, 10, 10, 1, 2, 3, 4, 5, 0}
  //erase()返回被删除的下一个元素迭代器，如果删除的是最后一个元素，则返回最后一个元素
  //*v3.erase(v3.end()-1)=0
  v3.erase(v3.end()-1); //{10, 10, 10, 1, 2, 3, 4, 5, 0}->{10, 10, 10, 1, 2, 3, 4, 5}
  v3.erase(v3.begin(), v3.begin()+3); //{10, 10, 10, 1, 2, 3, 4, 5}->{1, 2, 3, 4, 5}

• 清空

  v2.clear(); //{0, 0, 0, 10, 10, 10}->{}

• 判断是否存在

  //#include <algorithm> find();
  vector<int>::iterator it = find(v3.begin(), v3.end(), 0);
  if(it != v3.end()){
      //find it
  }
  else{
      //not found
  }

• 排序

  //升序
  sort(v3.begin(), v3.end());// sort(v3.begin(), v3.end(), less<int>());
  //降序
  //#include<functional> greater<int>()从大到小, less<int>()从小到大
  sort(v3.begin(), v3.end(), greater<int>());
  //还可以自己定义比较函数
  bool complare(int a,int b)
  {
      return a>b;
  }
  sort(v3.begin(), v3.end(), complare);

• 二级排序

  bool complare(pair<int, int> l,pair<int, int> r)
  {
      return l.first != r.first ? l.first < r.first : l.second > r.second;
  }
  //第一个元素按从小到大排序，第二个则是从大到小
  vector<pair<int, int>> vp{{1,1},{1,2},{2,2},{2,3},{3,3}};//{{1,1},{1,2},{2,2},{2,3},{3,3}}->{{1,2},{1,1},{2,3},{2,2},{3,3}}
  sort(vp.begin(), vp.end(), complare);

• 交换

  //vector.swap(v)交换两个容器的内容
  v1.swap(v3); // v1:{}->{5,4,3,2,1}, v3:{5,4,3,2,1}->{}
  swap(v1[0], v1[1]);// v1:{5,4,3,2,1}->{4,5,3,2,1}

  vector方法表格，引自https://github.com/huihut/interview/tree/master/STL#vector

方法	含义
vector	构造函数
~vector	析构函数，销毁容器对象
operator=	将新内容分配给容器，替换其当前内容，并相应地修改其大小
begin	返回指向容器中第一个元素的迭代器
end	返回指向容器中最后一个元素之后的理论元素的迭代器
rbegin	返回指向容器中最后一个元素的反向迭代器
rend	返回一个反向迭代器，指向中第一个元素之前的理论元素
cbegin	返回指向容器中第一个元素的常量迭代器（const_iterator）
cend	返回指向容器中最后一个元素之后的理论元素的常量迭代器（const_iterator）
crbegin	返回指向容器中最后一个元素的常量反向迭代器（const_reverse_iterator）
crend	返回指向容器中第一个元素之前的理论元素的常量反向迭代器（const_reverse_iterator）
size	返回容器中元素的数量
max_size	返回容器可容纳的最大元素数
resize	调整容器的大小，使其包含 n（参数）个元素
capacity	返回当前为 vector 分配的存储空间（容量）的大小
empty	返回 vector 是否为空
reserve	请求 vector 容量至少足以包含 n（参数）个元素
shrink_to_fit	要求容器减小其 capacity（容量）以适应其 size（元素数量）
operator[]	返回容器中第 n（参数）个位置的元素的引用
at	返回容器中第 n（参数）个位置的元素的引用
front	返回对容器中第一个元素的引用
back	返回对容器中最后一个元素的引用
data	返回指向容器中第一个元素的指针
assign	将新内容分配给 vector，替换其当前内容，并相应地修改其 size
push_back	在容器的最后一个元素之后添加一个新元素
pop_back	删除容器中的最后一个元素，有效地将容器 size 减少一个
insert	通过在指定位置的元素之前插入新元素来扩展该容器，通过插入元素的数量有效地增加容器大小
erase	从 vector 中删除单个元素（position）或一系列元素([first, last])，这有效地减少了被去除的元素的数量，从而破坏了容器的大小
swap	通过 x（参数）的内容交换容器的内容，x 是另一个类型相同、size 可能不同的 vector 对象
clear	从 vector 中删除所有的元素（被销毁），留下 size 为 0 的容器
emplace	通过在 position（参数）位置处插入新元素 args（参数）来扩展容器
emplace_back	在 vector 的末尾插入一个新的元素，紧跟在当前的最后一个元素之后
get_allocator	返回与vector关联的构造器对象的副本
swap(vector)	容器 x（参数）的内容与容器 y（参数）的内容交换。两个容器对象都必须是相同的类型（相同的模板参数），尽管大小可能不同
relational operators (vector)	形如 vectorA > vectorB;依此比较每个元素的大小关系