C++ STL容器库

ゝ一纸荒年。 2022-02-14 12:24 439阅读 0赞

C++ STL中最基本以及最常用的类或容器无非就是以下几个：

  • string
  • vector
  • set
  • list
  • map

下面就依次介绍它们，并给出一些最常见的最实用的使用方法，做到快速入门。

string

首先看看我们C语言一般怎么使用字符串的

  1. char* s1 = "Hello SYSU!"; //创建指针指向字符串常量，这段字符串我们是不能修改的
  3. //想要创建 可以修改的字符串，我们可以使用数组分配空间
  4. char s2[20] = "Hello SYSU!";
  5. //或者这样
  6. char s3[] = "Hello SYSU!";
  8. //当然我们也可以动态分配内存
  9. char* s4 = (char*)malloc(20）;
  10. gets(s4);

C++ 标准库中的string表示可变长的字符串，它在头文件string里面。

  1. #include <string>

用string初始化字符串分两类：用“=”号就是拷贝初始化，否则就是直接初始化。

1093303-20170602170725977-1802373773.png

  1. string s1;//初始化字符串，空字符串
  2. string s2 = s1; //拷贝初始化，深拷贝字符串
  3. string s3 = "I am Yasuo"; //直接初始化，s3存了字符串
  4. string s4(10, 'a'); //s4存的字符串是aaaaaaaaaa
  5. string s5(s4); //拷贝初始化，深拷贝字符串
  6. string s6("I am Ali"); //直接初始化
  7. string s7 = string(6, 'c'); //拷贝初始化，cccccc

1093303-20170602170743602-467536077.png

  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. int main()
  7. {
  8.     string s1;//初始化字符串，空字符串
  9.     string s2 = s1; //拷贝初始化，深拷贝字符串
  10.     string s3 = "I am Yasuo"; //直接初始化，s3存了字符串
  11.     string s4(10, 'a'); //s4存的字符串是aaaaaaaaaa
  12.     string s5(s4); //拷贝初始化，深拷贝字符串
  13.     string s6("I am Ali"); //直接初始化
  14.     string s7 = string(6, 'c'); //拷贝初始化，cccccc
  16.     //string的各种操作
  17.     string s8 = s3 + s6;//将两个字符串合并成一个
  18.     s3 = s6;//用一个字符串来替代另一个字符串的对用元素
  20.     cin >> s1;
  22.     cout << s1 << endl;
  23.     cout << s2 << endl;
  24.     cout << s3 << endl;
  25.     cout << s4 << endl;
  26.     cout << s5 << endl;
  27.     cout << s6 << endl;
  28.     cout << s7 << endl;
  29.     cout << s8 << endl;
  30.     cout << "s7 size = " << s7.size() << endl; //字符串长度，不包括结束符
  31.     cout << (s2.empty() ? "This string is empty" : "This string is not empty") << endl;;
  33.     system("pause");
  34.     return 0;
  35. }

1093303-20170602170758758-2074743989.png

string的IO操作

使用cin读入字符串时，遇到空白就停止读取。比如程序输入的是

  1. "     Hello   World"

那么我们得到的字符串将是”Hello”，前面的空白没了，后面的world也读不出来。

如果我们想把整个hello world读进来怎么办？那就这样做

  1. cin>>s1>>s2;

hello存在s1里，world存在s2里了。

有时我们想把一个句子存下来，又不想像上面那样创建多个string来存储单词，怎么办？

那就是用getline来获取一整行内容。

  1. string str;
  2. getline(cin, str);
  3. cout << str << endl;

当把string对象和字符面值及字符串面值混在一条语句中使用时，必须确保+的两侧的运算对象至少有一个是string

  1. string s1 = s2 + ", "; //正确
  2. string s3 = "s " + ", "; //错误
  3. string s4 = "hello" + ", " + s1; //错误
  4. string s5 = s1 + "hello " + ", "; //改一下顺序，s1放前头，正确了，注意理解=号右边的运算顺序

处理string中的字符

访问字符串的每个字符

  1. for (int i = 0; i < s3.size(); i++)
  2. {
  3.     cout << s3[i] << endl;
  4.     s3[i] = 's';
  5. }

在C语言中我都是用下标或者指针来访问数组元素，而在C++里，有个新奇的东西叫做迭代器iterator，我们可以使用它来访问容器元素。

1093303-20170602170813805-608759904.png

  1. string str("hi sysu");
  2. for (string::iterator it = str.begin(); it != str.end(); it++)
  3. {
  4.     cout << *it << endl;
  5. }

我们也可以是使用const_iterator使得访问元素时是能读不能写，这跟常量指针意思差不多。

  1. string str2("hi sysu");
  2. for (string::const_iterator it = str2.begin(); it != str2.end(); it++)
  3. {
  4.     cout << *it << endl;
  5.     *it = 'l'; //这是错误的，不能写
  6. }

1093303-20170602170831649-461472172.png

string还有一些很好用的函数，比如找子串

  1. string sq("heoolo sdaa ss");
  2. cout << s.find("aa", 0) << endl; //返回的是子串位置。第二个参数是查找的起始位置，如果找不到，就返回string::npos
  3. if (s.find("aa1", 0) == string::npos)
  4. {
  5.     cout << "找不到该子串！" << endl;
  6. }

vector

C++ STL中的verctor好比是C语言中的数组，但是vector又具有数组没有的一些高级功能。与数组相比，vector就是一个可以不用再初始化就必须制定大小的边长数组，当然了，它还有许多高级功能。

要想用vector首先得包含头文件vector。

  1. #include <vector>

怎么初始化？

1093303-20170602170846961-452229016.png

如果vector的元素类型是int，默认初始化为0；如果vector元素类型为string，则默认初始化为空字符串。

  1. vector<int> v1;
  2. vector<father> v2;
  3. vector<string> v3;
  4. vector<vector<int> >;  //注意空格。这里相当于二维数组int a[n][n];
  5. vector<int> v5 = { 1,2,3,4,5 }; //列表初始化,注意使用的是花括号
  6. vector<string> v6 = { "hi","my","name","is","lee" };
  7. vector<int> v7(5, -1); //初始化为-1,-1,-1,-1,-1。第一个参数是数目，第二个参数是要初始化的值
  8. vector<string> v8(3, "hi");
  9. vector<int> v9(10); //默认初始化为0
  10. vector<int> v10(4); //默认初始化为空字符串

如何向vector添加元素？

请使用push_back加入元素，并且这个元素是被加在数组尾部的。

  1. for (int i = 0; i < 20; i++)
  2. {
  3.     v1.push_back(i);
  4. }

vector其他的操作

1093303-20170602170900399-1317226831.png

访问和操作vector中的每个元素

  1. for (int i = 0; i < v1.size(); i++)
  2. {
  3.     cout << v1[i] << endl;
  4.     v1[i] = 100;
  5.     cout << v1[i] << endl;
  6. }

注意：只能对已存在的元素进行赋值或者修改操作，如果是要加入新元素，务必使用push_back。push_back的作用有两个：告诉编译器为新元素开辟空间、将新元素存入新空间里。

比如下面的代码是错误的，但是编译器不会报错，就像是数组越界。

  1. vector<int> vec;
  2. vec[0] = 1;  //错误！

当然我们也可以选择使用迭代器来访问元素

  1. vector<string> v6 = { "hi","my","name","is","lee" };
  2. for (vector<string>::iterator iter = v6.begin(); iter != v6.end(); iter++)
  3. {
  4.     cout << *iter << endl;
  5.     //下面两种方法都行
  6.     cout << (*iter).empty() << endl;
  7.     cout << iter->empty() << endl; 
  8. }

上面是正向迭代，如果我们想从后往前迭代该如何操作？
使用反向迭代器

  1. for (vector<string>::reverse_iterator iter = v6.rbegin(); iter != v6.rend(); iter++)
  2. {
  3.     cout << *iter << endl;
  5. }

vector最常用的增删操作

1093303-20170602170914508-1325887310.png

  1. #include <iostream>
  2. #include <vector>
  3. #include <string>
  5. using namespace std;
  7. template <typename T>
  8. void showvector(vector<T> v)
  9. {
  10.     for (vector<T>::iterator it = v.begin(); it != v.end(); it++)
  11.     {
  12.         cout << *it;
  13.     }
  14.     cout << endl;
  15. }
  17. int main()
  18. {
  19.     vector<string> v6 = { "hi","my","name","is","lee" };
  20.     v6.resize(3);  //重新调整vector容量大小
  21.     showvector(v6);
  23.     vector<int> v5 = { 1,2,3,4,5 }; //列表初始化,注意使用的是花括号
  24.     cout << v5.front() << endl; //访问第一个元素
  25.     cout << v5.back() << endl; //访问最后一个元素
  27.     showvector(v5);
  28.     v5.pop_back(); //删除最后一个元素
  29.     showvector(v5);
  30.     v5.push_back(6); //加入一个元素并把它放在最后
  31.     showvector(v5);
  32.     v5.insert(v5.begin()+1,9); //在第二个位置插入新元素
  33.     showvector(v5);
  34.     v5.erase(v5.begin() + 3);  //删除第四个元素
  35.     showvector(v5);
  36.     v5.insert(v5.begin() + 1, 7,8); //连续插入7个8
  37.     showvector(v5);
  38.     v5.clear(); //清除所有内容
  39.     showvector(v5);
  41.     system("pause");
  42.     return 0;
  43. }

1093303-20170602170927321-678572314.png

注意：虽然vertor对象可以动态增长，但是也或有一点副作用：已知的一个限制就是不能再范围for循环中向vector对象添加元素。另外一个限制就是任何一种可能改变vector对象容量的操作，不如push_back，都会使该迭代器失效。

总而言之就是：但凡使用了迭代器的循环体，都不要向迭代器所属的容器添加元素！

C++中push_back和insert两个有什么区别?

顾名思义push_back把元素插入容器末尾，insert把元素插入任何你指定的位置。
不过push_back速度一般比insert快。如果能用push_back尽量先用push_back。

set

set跟vector差不多，它跟vector的唯一区别就是，set里面的元素是有序的且唯一的，只要你往set里添加元素，它就会自动排序，而且，如果你添加的元素set里面本来就存在，那么这次添加操作就不执行。要想用set先加个头文件set。

  1. #include <set>
  3. #include <iostream>
  4. #include <set>
  5. #include <string>
  7. using namespace std;
  9. template <typename T>
  10. void showset(set<T> v)
  11. {
  12.     for (set<T>::iterator it = v.begin(); it != v.end(); it++)
  13.     {
  14.         cout << *it;
  15.     }
  16.     cout << endl;
  17. }
  19. int main()
  20. {
  21.     set<int> s1{9,8,1,2,3,4,5,5,5,6,7,7 }; //自动排序，从小到大,剔除相同项
  22.     showset(s1);
  23.     set<string> s2{ "hello","sysy","school","hello" }; //字典序排序
  24.     showset(s2);
  25.     s1.insert(9); //有这个值了，do nothing
  26.     showset(s1);
  27.     s2.insert("aaa"); //没有这个字符串，添加并且排序
  28.     showset(s2);
  30.     system("pause");
  31.     return 0;
  32. }

1093303-20170602170939664-2054900441.png

list

list就是链表，在C语言中我们想使用链表都是自己去实现的，实现起来倒不难，但是如果有现成的高效的链表可以使用的话，我们就不需要重复造轮子了。STL就提供了list容器给我们。

list是一个双向链表，而单链表对应的容器则是foward_list。

list即双向链表的优点是插入和删除元素都比较快捷，缺点是不能随机访问元素。

初始化方式就大同小异了，跟vector基本一样。要想用list先加个头文件list。

  1. #include <list>
  3. #include <iostream>
  4. #include <list>
  5. #include <string>
  7. using namespace std;
  9. template <typename T>
  10. void showlist(list<T> v)
  11. {
  12.     for (list<T>::iterator it = v.begin(); it != v.end(); it++)
  13.     {
  14.         cout << *it;
  15.     }
  16.     cout << endl;
  17. }
  19. int main()
  20. {
  21.     list<int> l1{ 1,2,3,4,5,5,6,7,7 };
  22.     showlist(l1);
  23.     list<double> l2;
  24.     list<char> l3(10);
  25.     list<int> l4(5, 10); //将元素都初始化为10
  26.     showlist(l4);
  29.     system("pause");
  30.     return 0;
  31. }

1093303-20170602170954446-909787830.png

值得注意的是，list容器不能调用algorithm下的sort函数进行排序，因为sort函数要求容器必须可以随机存储，而list做不到。所以，list自己做了一个自己用的排序函数，用法如下：

  1. list<int> l1{ 8,5,7,6,1,2,3,4,5,5,6,7,7 };
  2. l1.sort();

map

map运用了哈希表地址映射的思想，也就是key-value的思想，来实现的。

首先给出map最好用也最最常用的用法例子，就是用字符串作为key去查询操作对应的value。

要使用map得先加个头文件map。

  1. #include <map>
  3. #include <iostream>
  4. #include <map>
  5. #include <string>
  7. using namespace std;
  9. void showmap(map<string, int> v)
  10. {
  11.     for (map<string, int>::iterator it = v.begin(); it != v.end(); it++)
  12.     {
  13.         cout << it->first << "  " << it->second << endl;  //注意用法，不是用*it来访问了。first表示的是key，second存的是value
  14.     }
  15.     cout << endl;
  16. }
  18. int main()
  19. {
  20.     map<string, int> m1; //<>里的第一个参数表示key的类型,第二个参数表示value的类型
  21.     m1["Kobe"] = 100;
  22.     m1["James"] = 99;
  23.     m1["Curry"] = 98;
  25.     string s("Jordan");
  26.     m1[s] = 90;
  28.     cout << m1["Kobe"] << endl;
  29.     cout << m1["Jordan"] << endl;
  30.     cout << m1["Durant"] << endl; //不存在这个key，就显示0
  32.     m1.erase("Curry");//通过关键字来删除
  33.     showmap(m1);
  34.     m1.insert(pair<string, int>("Harris", 89)); //也可以通过insert函数来实现增加元素
  35.     showmap(m1);
  36.     m1.clear(); //清空全部
  39.     system("pause");
  40.     return 0;
  41. }

1093303-20170602171006649-580201339.png

如果想看看某个存不存在某个key，可以用count来判断

  1. if (m1.count("Lee"))
  2. {
  3.     cout << "Lee is in m1!" << endl;
  4. }
  5. else
  6. {
  7.     cout << "Lee do not exist!" << endl;
  8. }

用迭代器来访问元素

  1. for (map<string, int>::iterator it = m1.begin(); it != m1.end(); it++)
  2. {
  3.     cout << it->first<<"  "<<it->second << endl;  //注意用法，不是用*it来访问了。first表示的是key，second存的是value
  4. }

转载地址：https://www.cnblogs.com/skyfsm/p/6934246.html

发表评论

表情：
评论列表 （有 0 条评论，439人围观）

还没有评论，来说两句吧...

相关阅读

    相关 C/C++编程：STL容器

    容器 有三类容器——顺序容器、关联容器和无序关联容器——每种都被设计为支持不同组的操作。 ![watermark_type_ZmFuZ3poZW5naGVpdGk_s

    小鱼儿小鱼儿/ 0 赞/ 482 阅读

    相关 c++ 容器STL

    STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的

    分手后的思念是犯贱分手后的思念是犯贱/ 0 赞/ 472 阅读