STL常用容器

目录​​​​​​​

1 string容器

1.1 基本概念

1.2 构造函数

1.3 赋值操作

1.4 字符串拼接

1.5 查找和替换

1.6 字符串比较

1.7 字符存取

1.8 插入与删除

1.9 获取字串

2 vector容器

2.1 基本概念

2.2 构造函数

2.3 赋值操作

2.4 容量和大小

2.5 插入和删除

2.6 数据存取

2.7 互换容器

2.8 预留空间

3 deque容器

3.1 基本概念

3.2 示例

3.3 构造函数

3.4 赋值操作

3.5 容量和大小

3.6 插入与删除

3.7 数据存取

3.8 排序

4 案例：评委打分

4.1 案例说明

4.2 实现步骤

1 string容器

1.1 基本概念

本质

string是C++风格的字符串，但其本质是一个类

对比

• 在C语言中，字符串是char*，但本质是一个指针

• 而string是一个类，其内部封装了char*，管理这个字符串，但容器本身也是char*类型的

特点

• string类内封装了很多成员方法，如：find、copy、delete、replace、insert等

• string管理char*所分配的内存，不用担心复制越界和取值越界等问题，由类内部进行负责

1.2 构造函数

 /*
  string ();创建一个空的字符串
  string(const char* c);使用字符串c初始化
  string(const string&str);使用一个string对象初始化另一个string对象
  string(int n,char c);使用n个字符c初始化
 */

测试 

 void test01()
 {
   // 
   string s1;// 创建一个空的字符串
 ​
   const char* str = "Type here";
   string s2(str); // 把c的string转换成c++的string
   cout << s2 << endl;
   string s3(s2);  // ，使用一个string对象初始化另一个string对象
   cout << s3 << endl;
   string s4(88, 'x');// 使用n个字符x初始化s4
   cout << s4 << endl;
 }

1.3 赋值操作

作用：将字符或字符串赋值给字符串

函数

 /*字符串赋值
  string& operator=(const char* s);    1 把char*类型字符串 赋值给 当前字符串
  string& operator=(const string& s);  2 把字符串s 赋值给 当前字符串
  string& operator=(char c);         3 把字符c 赋值给 当前字符串
  string& assign(const char* s);   4 把字符串s 赋值给 当前字符串
  string& assign(const char* s,int n); 5 把字符串s前n个字符 赋值给 当前字符串
  string& assign(const string& s,int n);5 除去字符串s前n个字符 剩下的赋值给 当前字符串
  string& assign(const string& s);   6 把字符串s 赋值给 当前字符串
  string& assign(int n,char c);      7 把n个字符c 赋值给 当前字符串
 */

使用：无非就是前面用=号，后面用.assign()函数

测试 

 void test02()
 {
   const char* str0 = "Type there";
   string str1;
   str1 = str0;    // 1 
   str1 = "Type here"; // 1
   cout << str1 << endl;
   
   string str2;
   str2 = str1;    // 2
   cout << str2 << endl;
 ​
   string str3;
   str3 = 'x';     // 3
   cout << str3 << endl;
 ​
   string str4;
   str4.assign(str0);  // 4
   cout << str4 << endl;
 ​
   string str5;
   str5.assign(str0,4);// 5 传入const char*,前面4个
   cout << str5 << endl;
   str5.assign(str1, 4);// 5 传入string& s，除去前面4个剩下的
   cout << str5 << endl;
 ​
   string str6;
   str6.assign(str1);  // 6
   cout << str6 << endl;
 ​
   string str7;
   str7.assign(88, 'c');// 7
   cout << str7 << endl;
 }

不过有趣的是，在第5个// string& assign(const char* s,int n);时，如果传入const char* s，输出的将是前字符串前n个；如果传入的是const string& s，输出的是除去前n个所剩下的 ​

1.4 字符串拼接

作用：将字符或字符串拼接到字符串后

函数

 /*字符串拼接
  string& operator+=(const char* s);     1 把char*类型字符串 拼接到当前字符串末尾
  string& operator+=(const string& s); 2 把字符串s 拼接到当前字符串末尾
  string& operator+=(const char c);    3 把字符c 拼接到当前字符串末尾
  string& append(const char* s);   4 把字符串s 拼接到当前字符串末尾
  string& append(const char* s,int n);   5 把字符串s前n个字符 拼接到当前字符串末尾
  string& append(const string& s,int n); 5 把字符串s除去前n个字符 剩下的拼接到当前字符串末尾
  string& append(const string& s);   6 把字符串s 拼接到当前字符串末尾
  string& append(const string& s,int pos,int n);7 把字符串s从pos开始位置的n个字符 拼接到当前字符串末尾
 */

前面就是+=号重载，后面用append()函数

测试

 void test03()
 {
   string str1 = "I";
   const char* s = " am ";
   //str1 += " am ";     // 1
   str1 += s;          // 1
   cout << str1 << endl;
 ​
   string str2 = "studious";
   str1 += str2;       // 2
   cout << str1 << endl;
 ​
   str1 += 'o';
   cout << str1 << endl;   // 3
 ​
   const char* s1 = " are ";
   string str3 = "You";
   str3.append(s1);    // 4
   cout << str3 << endl;
 ​
   str3.append(s1, 3);   // 5 把s1前3个字符追加到后面
   cout << str3 << endl;
   str3.append(str1, 3); // 5 把str1除去前3个字符，剩下的追加到后面
   cout << str3 << endl; 
 ​
   str3.append(str1);
   cout << str3 << endl; // 6
 ​
   string str4;
   str4.append(str3, 11, 14);//7
   cout << str4 << endl;
 }

同样的，在第5个// string& append(const char* s,int n);时，如果传入const char* s，加在后面的的将是前字符串前n个；如果传入的是const string& s，加在后面的的是除去前n个所剩下的字符串

1.5 查找和替换

作用

• 查找：查找指定字符串

• 替换：在指定的位置替换字符串

函数

 /* 字符串查找与替换
  找第一次
 int find(const string& s,int pos = 0)const;  1从pos位置查找字符串s第一次出现位置
 int find(const char* s,int pos = 0)const;  2从pos位置查找字符串s第一次出现位置
 int find(const char* s,int pos,int n)const;  3从pos位置查找字符串s的前n个字符第一次出现位置
 int find(const char c,int pos = 0)const;   4从pos位置查找字符c第一次出现位置
  找最后一次
 int rfind(const string& s,int pos = npos)const; 5从pos位置查找字符串s最后一次出现位置
 int rfind(const char* s,int pos = npos)const; 6从pos位置查找字符串s最后一次出现位置
 int rfind(const char* s,int pos,int n)const;  7从pos位置查找字符串s前n个字符最后一次出现位置
 int rfind(const char c,int pos = 0)const;   8从pos位置查找字符c最后一次出现位置
  替换
 string& replace(int pos,int n,const string& s); 9将pos位置开始n个字符替换为字符串s
 string& replace(int pos,int n,const char* s);  10将pos位置开始n个字符替换为字符串s
 */

注意，find从左往右找，rfind从右往左找，但2个都是从左向右计数，找到返回位置，否则返回-1

查找

 void test04()
 {
   // 查找
   string s1 = "abcdefgcd";
   int pos = s1.find("cd"); // 不传pos则默认从0开始找字符cd第一次出现位置
   cout << pos << endl;
   pos = s1.rfind("cd");// 不传pos则默认从0开始找字符cd最后一次出现位置
   cout << pos << endl;
 ​
   int pos1 = s1.find("cd", 3);// 从3开始找字符cd第一次出现位置
   cout << pos1 << endl;
   pos1 = s1.rfind("cd",3);  // 从3开始找字符cd最后一次出现位置
   cout << pos1 << endl;
 ​
   int pos2 = s1.find("cd", 3, 1); // 从3开始找字符串cd的前1个字符第一次出现位置
   cout << pos2 << endl;
   pos2 = s1.rfind("cd", 3, 1); // 从3开始找字符串cd的前1个字符最后一次出现位置
   cout << pos2 << endl;
 }

注意，a是0位置，b是1位置....

替换

 void test05()
 {
   // 替换
   string s1 = "abcdefgcd";
   string str = " hello my ";
   s1.replace(2, 5, str);// 从2开始前5个字符替换为str
   cout << s1 << endl;
 }

1.6 字符串比较

作用：进行字符串之间的比较

比较方式：逐个按字符的ASCII码进行对比

• =返回0

• >返回1

• <返回-1

函数

 /*字符串比较
 int compare(const string& s)const;  与字符串s比较
 int compare(const char* s)const;    与字符串s比较
 */

测试

 void test06()
 {
   string s1 = "abcdefg";
   string s2 = "abcdefg"; // 等于 0
   string s3 = "abcdef";  // 大于 1
   string s4 = "abcdefgh";// 小于 -1
   int ret = s1.compare(s2);
   cout << ret << endl;
   ret = s1.compare(s3);
   cout << ret << endl;
   ret = s1.compare(s4);
   cout << ret << endl;
 }

其实compare最大用处在于对比字符串是否相等

1.7 字符存取

作用：存取string中单个字符

 /*字符存取
 char& operator[](int n);  通过[]读取字符
 char& at(int n);      通过at方法获取字符
 */

• 读字符

 void test07()
 {
   // 1 通过[]方式读取字符
   string s = "Type here";
   for (int i = 0; i < s.size(); i++)
   {         // .size()可以返回字符s的长度
     cout << s[i] << " ";
   }
   cout << endl;
   // 2 通过at方式读取字符
   for (int i = 0; i < s.size(); i++)
   {
     cout << s.at(i) << " ";
   }
 }

• 修改字符

   // 通过[]修改字符
   s[0] = 't';
   cout << s << endl;
   // 通过at修改字符
   s.at(1) = 'Y';
   cout << s << endl;

1.8 插入与删除

作用：对字符串进行插入和删除操作

函数

 /*插入和删除
  string& insert(int pos,const char* s);  在pos位置插入字符串s
  string& insert(int pos,const string& s);在pos位置插入字符串s
  string& insert(int pos,int n,char c);   在pos位置插入n个字符c
  string& erase(int pos,int n = npos);    删除从pos开始的n个字符
 */

测试 

 void test08()
 {
   string s1 = "Type here";
   s1.insert(0, "ok");   // 1 char* 从0开始加上ok字符
   cout << s1 << endl;
 ​
   string s2 = "ko";
   s1.insert(0, s2);     // 2 string& 从0开始加上ko字符
   cout << s1 << endl;
 ​
   s1.insert(0, 8, '+'); // 3 从0开始加上8个字符+
   cout << s1 << endl;
 ​
   s1.erase(0, 12);      // 4 从位置0开始删除okko4个和8个+一共12个字符
   cout << s1 << endl;
 }

1.9 获取字串

作用：从字符串中获取想要的字串

函数

 /* 获取字串
 string substr(int pos,int n=npos)const; // 返回由pos开始n个字符组成的字符串
 */

测试

 void test09()
 {
   string s1 = "Type there";
   string s2 = s1.substr(5, 5);
   cout << s2 << endl;
 }

实际使用举例

 void test10()
 {
   string user_email = "Joyce@Gmail.com";
   // 根据邮箱获取用户名称
   int pos = user_email.find('@');// 从email中读取@字符所在的位置，这里是位置5
   string user_name = user_email.substr(0, pos); // 截取0-5的字符
   cout << user_name << endl;
 }

以上就是string容器的所有内容

2 vector容器

2.1 基本概念

功能：vector数据结构与数组十分相似，也称为单端数组

区别：数组是静态空间，确定大小后无法扩展，vector可以动态扩展

动态扩展：为防止在vector原空间之后没有可用空间来扩展，其动态扩展实际上是重新寻找一块更大的空间，先将原有数据拷贝进去，再释放原空间

如图，有这些迭代器，常用的是v.begin()与v.end()。

而vector的迭代器是支持随机访问的迭代器

2.2 构造函数

功能：即创建vector容器

 /*构造函数
 vector<T> v;         1使用模板实现类的实现，默认构造函数
 vector(v.begin(),v.end()); 2将v[v.begin(),v.end())区间中的元素赋给自身，注意区间左闭右开
 vector(n,elem);        3将n个elem元素拷贝给自身
 vector(const vector& v);   4拷贝构造函数，将v拷贝给自身
 */

测试​​​​​​​ 

 void test01()
 {
   vector<int> v1; // 1默认构造
   for (int i = 0; i < 10; i++)
   {
     v1.push_back(i);
   }
   printV(v1);
 ​
   vector<int> v2(v1.begin(), v1.end()); // 2
   printV(v2);
 ​
   vector<int> v3(10, 888); // 3，10个888赋给v3
   printV(v3);
 ​
   vector<int>v4(v3); // 4拷贝构造
   printV(v4);
 }

额外的，我再实现一个打印容器中数据的函数printV

 void printV(vector<int>& v)
 {
   for (vector<int>::iterator it=v.begin();it<v.end();it++)
   {
     cout << *it<< " ";
   }
   cout << endl;
 }

运行：

2.3 赋值操作

功能：给vector容器赋值

 /*赋值操作
 vector& operator=(const vector& v); 1 =赋值，重载=运算符
 assign(begin,end);          2 将[begin,end)区间中的数据赋给自身，注意区间左闭右开
 assign(n,elem);           3 将n个elem赋给自身
 */

测试 

 void test02()
 {
   vector<int>  v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
 ​
   vector<int> v2;
   v2 = v1;      // 1 直接=赋值
   printV(v2);
 ​
   vector<int> v3;
   v3.assign(v2.begin(), v2.end()); // 2 区间赋值
   printV(v3);
 ​
   vector<int> v4;
   v4.assign(10, 888); // 3 将10个888赋给自身
   printV(v4);
 }

2.4 容量和大小

功能：对vector容器的容量和大小进行操作

 /*容量和大小
 v.empty();       判断容器是否为空，空返回true否则false
 v.capacity();    返回容器容量
 v.size();        返回容器当前大小
 v.resize(int n);   重新指定容器长度为n，若容器变长，则以默认值0填充新位置。
                         若容器变短，则末尾超出容器长度的元素被删除
 v.resize(int n,elem);重新指定容器长度为n，若容器变长，则以elem填充新位置。
                       若容器变短，则末尾超出容器长度的元素被删除
 */

• 容量与大小的输出

 void test03() // 判断为空、容量、大小
 {
   vector<int> v1; 
   for (int i = 0; i < 10; i++)
   {
     v1.push_back(i);
   }
   printV(v1);
 ​
   cout << v1.empty() << endl;   // 判断为空，ture=1，false=0
   cout << v1.capacity() << endl;  // 容量
   cout << v1.size() << endl;    // 大小
 }

• 修改size

 void test04()
 {
   vector<int> v1;
   for (int i = 0; i < 10; i++)
   {
     v1.push_back(i);
   }
   printV(v1);
   vector<int> v2 = v1; // v1赋给v2
   v2.resize(16);  // 变长，默认用0填充
   printV(v2);
   v2.resize(5); // 变短
   printV(v2);
   v2.resize(16, 'm'); // 变长且更换元素
   printV(v2);
 }

2.5 插入和删除

功能：对vector容器进行插入与删除的操作

 /*插入与删除
 v.push_back(elem);       尾部插入elem元素
 v.pop_back();        删除尾部最后一个元素
 v.insert(const_iterator pos,elem);          在迭代器指向的pos位置插入元素elem
 v.insert(const_iterator pos,int n,elem);      在迭代器指向的pos位置插入n个elem元素
 v.erase(const_iterator pos); 删除迭代器指向的pos位置的元素
 v.erase(const_iterator start,const_iterator end); 删除迭代器指向的从start到end区间的元素
 v.clear();           删除容器中所有元素
 */

测试：

 void test05()
 {
   vector<int>  v1; 
   v1.push_back(1);       // 1尾插元素
   v1.push_back(2);
   v1.push_back(3);
   v1.push_back(4);
   printV(v1);
 ​
   v1.pop_back();         // 2尾删元素
   v1.pop_back();
   printV(v1);
 ​
   v1.insert(v1.begin(), 'x');  // 3在begin位置插入元素'x'，
   printV(v1);
 ​
   v1.insert(v1.end(), 10, 888);// 4在end位置插入10个888
   printV(v1);
 ​
   v1.erase(v1.begin());    // 5删除begin位置的元素 头删元素
   printV(v1);
 ​
   v1.erase(v1.begin()+2, v1.end()); // 6删除下标为2开始到end区间内的元素
   printV(v1);
 ​
   v1.clear();          // 7清空所有元素
   printV(v1);
 }

2.6 数据存取

功能：对vector容器中的元素进行读取与存储

 /*数据存取
 v.at(int pos);  1返回pos位置处的元素
 operator[pos];  2重载[]，也返回pos处的元素
 v.front();    3返回容器中第一个元素
 v.back();   4返回容器中最后一个元素
 */

测试：

 void test06()
 {
   vector<int> v1;
   for (int i = 0; i < 10; i++)
   {
     v1.push_back(i);
   }
   printV(v1);
 ​
   cout << v1.at(3) << endl;  // 1返回位置3处的元素
   cout << v1[3] << endl;     // 2返回位置3处的元素
   cout << v1.front() << endl;// 3返回容器中第一个元素
   cout << v1.back() << endl; // 4返回容器中最后一个元素
 }

2.7 互换容器

功能：实现两个容器内元素进行互换

 // v1.swap(v2); 将v2的元素与自身v1交换 

测试：

 void test07()
 {
   vector<int> v1;
   for (int i = 0; i < 10; i++)
   { // 给v1初始化
     v1.push_back(i);
   }
   cout << " v1:";
   printV(v1);
 ​
   vector<int> v2;
   for (int i = 9; i >= 0; i--)
   { // 给v2初始化
     v2.push_back(i);
   }
   cout << " v2:";
   printV(v2);
 ​
   v1.swap(v2);  // 交换v1与v2的元素
   cout << " v1:";
   printV(v1);
   cout << " v2:";
   printV(v2);
 }

实际用途：如收缩容器

示例

我们创建一个vector容器v1，在其中存入888888个元素

   vector<int> v1;
   for (int i = 0; i < 888888; i++)
   {
     v1.push_back(i);
   }
   cout << v1.capacity() << endl;  // 容量
   cout << v1.size() << endl;    // 大小

打印输出容器的容量与大小

容量是1049869，大小是888888

接下来，我们使用resize函数重新指定容器大小为5

   v1.resize(5);
   cout << v1.capacity() << endl;  // 容量
   cout << v1.size() << endl;    // 大小

输出容器容量与大小

可以发现，容器的容量仍然是1049869，而大小却只有5``个元素 ，这样就极大的浪费了空间

接下来我们使用swap函数解决：

   vector<int>(v1).swap(v1);
   cout << v1.capacity() << endl;  // 容量
   cout << v1.size() << endl;    // 大小

这样就解决了浪费空间的问题

原理

这是resize后的v1，使用的大小很小一点，容量很大

接下来使用**vector<int>(v1).swap(v1);函数**

首先，前面的

vector<int>(v1)是创建一个匿名对象，它会使用v1的实际使用大小来初始化一个新的对象

假设是v2，v2的空间就是：一小点

然后，后面的.swap(v1)就是将匿名对象创建的对象（v2）与v1交换元素

这样就实现了v1交换到了同样数据但容量更小的容器

2.8 预留空间

功能：减少vector在动态扩展时的扩展次数

  v.reserve(int len); 容器预留len个长度空间，但不初始化这块空间，因此元素不可访问

测试：

• ①我们创建容器v1，为其开辟888888个元素空间，并使用number计数与指针p记录容器首元素的地址，如果容器首元素的地址改变，则说明容器发生了扩容

 vector<int> v1;
   int number = 0; // 计数
   int* p = NULL;  // 保存首地址
   for (int i = 0; i < 888888; i++)
   {
     v1.push_back(i);
     if (p != &v1[0]) // 如果v1的首元素地址变了，就是重新开辟内存了
     {
       p = &v1[0];
       number++;// 计数+1
     }
   }
   cout << number << endl;

可以看到，为使容器开辟到888888个元素空间，容器一共扩展35次

• ②接下来，我们使用reserve函数为容器预留888889空间 ，然后重复①的代码

 vector<int> v2;
   int number1 = 0; // 计数
   v2.reserve(888889); // 预留888889空间
   int* p1 = NULL;  // 保存首地址
   for (int i = 0; i < 888888; i++)
   {
     v2.push_back(i);
     if (p1 != &v2[0]) // 如果v1的首元素地址变了，就是重新开辟内存了
     {
       p1 = &v2[0];
       number1++;// 计数+1
     }
   }
   cout << number1 << endl;

可以看到只有1次，是我们最初初始化的那一次

因此，如果我们要使用较大的空间，可以一开始就预留一部分很大的空间

以上就是vector容器的全部内容

3 deque容器

3.1 基本概念

deque ：double ended queue ，双端队列

功能

相当于一个双端数组，可以对头部和尾部进行插入与删除操作，但其空间并不完全连续

与vector的区别

• vector对于头部的插入效率低，要先将数据向后移动才能插入，数据越多，效率越低

• deque对头部的插入与删除操作效率高

• vector访问元素时速度更快

同样的，deque容器也有很多迭代器，不过多了头插与头删等。

duque工作原理

deque内部有个中控器，其中维护的是每个缓冲区的地址，而缓冲区中存放的是真实的数据

当一片缓冲区满了后，会再找另一片缓冲区存入元素，使得我们使用deque容器时似乎它是一片连续的空间

而同时，由于每次寻找元素都要先找到中控器中的地址，所以它效率比vector低

而deque容器的迭代器也支持随机访问

3.2 示例

首先，我们实现一个打印函数，以打印出所有我们创建出的deque容器的值

 void printD(deque<int> d)
 {
   for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
   {
     cout << *it << " ";
   }
   cout << endl;
 }

而为了防止it在遍历时被修改（使容器为只读状态），我们可以在参数列表前加上const，但这样，循环里的迭代器也要加上const

 void printD(const deque<int> d) // 加上const
 {
   for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
   {     // 改成const_iterator
     cout << *it << " ";
   }
   cout << endl;
 }

3.3 构造函数

 /*构造函数
 deque<T> deqT;    1默认构造函数
 deque(begin,end); 2将[begin,end)区间中的元素拷贝给自身，注意区间左闭右开
 deque(n,elem);    3将n个elem拷贝给自身
 deque(const deque &deq); 4拷贝构造函数，将deq拷贝给自身
 */

测试

 void test01()
 {
   deque<int> d; // 1默认构造  
   for (int i = 0; i < 10; i++)
   {
     d.push_back(i);
   }
   printD(d);
 ​
   deque<int> d1(d.begin() + 2, d.end()-3); // 2将d的区间[2,6)中的数据拷贝给d1
   printD(d1);
 ​
   deque<int> d2(8, 888); // 3将8个888赋给自身d2
   printD(d2);
 ​
   deque<int> d3(d2); // 4将d2拷贝构造给自身d3
   printD(d3);
 }

3.4 赋值操作

功能：给deque容器赋值

 /*赋值操作
 deque& operator=(const deque& deq); 1就是重载=操作符
 deq.assign(begin,end);      2将[begin,end)区间中的元素拷贝给自身，注意区间左闭右开
 deq.assign(n,elem);       3将n个elem拷贝给自身
 */

测试

 void test02()
 {
   deque<int> d1; 
   for (int i = 0; i < 10; i++)
   {
     d1.push_back(i);
   }
   printD(d1);
 ​
   deque<int> d2 = d1; // 1直接=赋值
   printD(d2);
 ​
   deque<int> d3;
   d3.assign(d2.begin() + 2, d2.end() - 3); // 2将d2的区间[2,6)中的数据拷贝给d3
   printD(d3);
 ​
   deque<int> d4;
   d4.assign(8,66); // 3将8个66赋给自身
   printD(d4);
 }

3.5 容量和大小

功能：对deque容量的容量和大小进行操作

 /*容量和大小
 deq.empty();     1判断容器是否为空，空返回true否则false
 deq.size();        2返回容器当前大小
 deq.resize(int n);   3重新指定容器长度为n，若容器变长，则以默认值0填充新位置。
                         若容器变短，则末尾超出容器长度的元素被删除
 deq.resize(int n,elem);4重新指定容器长度为n，若容器变长，则以elem填充新位置。
                       若容器变短，则末尾超出容器长度的元素被删除
 */

测试

 void test03() // 判断为空、容量、大小
 {
   deque<int> d1; 
   for (int i = 0; i < 10; i++)
   {
     d1.push_back(i);
   }
   printD(d1);
 ​
   cout << d1.empty() << endl;   // 1判断为空，ture=1，false=0
   cout << d1.size() << endl;    // 2返回大小
 ​
   d1.resize(15); // 3变长 ，默认值为0
   printD(d1);
 ​
   d1.resize(20,'v'); // 3变长，默认为为118
   printD(d1);
 ​
   d1.resize(5); // 4变短
   printD(d1);
 }

3.6 插入与删除

功能：向deque容器中插入和删除数据

 /*插入与删除
 d.push_front(elem);     1 头插元素
 d.pop_front();        2.头删元素
 d.push_back(elem);      3 尾部插入elem元素
 d.pop_back();       4 删除尾部最后一个元素
 d.insert( iterator pos,elem);   5 在迭代器指向的pos位置插入元素elem的拷贝，返回新数据的位置
 d.insert( iterator pos,int n,elem); 6 在迭代器指向的pos位置插入n个elem元素，无返回值
 d.insert(iterator  pos,begin,end);  7 在迭代器指向的pos位置插入区间[begin,end)的元素，无返回值，注意区间左闭右开
 d.erase( iterator pos);       8 删除迭代器指向的pos位置的元素，返回下一个元素的位置
 d.erase( begin,end);    9 删除begin到end区间的元素，返回下一个元素的位置
 d.clear();          10 删除容器中所有元素
 */

测试

 void test04()
 {
   deque<int> d1;
   d1.push_front(10); // 1头插10与30
   d1.push_front(30);
   d1.push_back(3); // 3尾插3与1
   d1.push_back(1);
   // 顺序：30 10 3 1
   printD(d1);
 ​
   d1.pop_back();  // 4尾删
   d1.pop_front(); // 2头删
   printD(d1);
 ​
   d1.insert(d1.begin() + 1, 5); // 5在d1.begin后一个位置插入元素5
   printD(d1);
   
   d1.insert(d1.end(), 5, 888);  // 6在d1.end位置插入5个888
   printD(d1);
 ​
   d1.insert(d1.begin() + 2, d1.begin() + 2, d1.end() - 1); 
   // 7在d1.begin+2的位置插入d1容器中区间[d1.begin+2，d1.end-1)中的元素
   printD(d1);
 ​
   d1.erase(d1.begin()+1); // 8删除d1.begin+1位置的元素 3
   printD(d1);
 ​
   d1.erase(d1.begin() + 1,d1.end()-3); // 9删除区间d1.begin+1到d1.end之间的元素
   printD(d1);
 ​
   d1.clear();   // 清空
   printD(d1); 
 }

一个printD函数对应一行数据

3.7 数据存取

功能：对deque中的容量进行存取操作

 /*数据存取
 d.at(int pos);  1返回pos位置处的元素
 operator[pos];  2重载[]，也返回pos处的元素
 d.front();    3返回容器中第一个元素
 d.back();   4返回容器中最后一个元素
 */

测试

 void test05()
 {
   deque<int> d1;
   for (int i = 0; i < 10; i++)
   {
     d1.push_back(i);
   }
   printD(d1);
   cout << d1.at(5) << endl;
   cout << d1[5] << endl;
   cout << d1.front() << endl;
   cout << d1.back() << endl;
 }

3.8 排序

功能：对deque中的元素进行排序

算法

 // 排序
 //  sort(iterator begin,iterator end); 对区间begin到end中间的元素进行排序
 #include<algorithm> // 标准算法头文件

记得包含标准算法头文件

测试

 void test06()
 {
   deque<int> d1;
   srand((unsigned)time(NULL));
   for (int i = 0; i < 15; i++)
   {
     int num = rand()%100; // 随机数
     d1.push_back(num); // 尾插
   }
   printD(d1);
 ​
   sort(d1.begin(), d1.end()); // 进行升序排序
   printD(d1);
 }

​​​​​​​

vector容器也可以

总结：对于支持随机访问的迭代器的容器，都可以用sort算法直接进行排序

4 案例：评委打分

4.1 案例说明

有5名选手：ABCDE，10个评委分别对每一位选手打分，分数从60-100之间，去除最高分和最低分，取出每位选手的平均分

4.2 实现步骤

• 创建选手类person，内包含name与score属性，并创建五名选手，将选手放到vector容器中

• 遍历vector容器中的选手，为每一位选手进行打分并将分数存入deque容器中

• 分别对每位选手的分数进行排序，然后去除最高分和最低分

• 累加剩下的分数并取平均值，存入选手的score属性中

• 输出打印选手与平均分

 // 选手类
 class person
 {
 public:
   person(string name, int score)
   {
     this->m_name = name;
     this->m_score = score;
   }
   string m_name; //姓名
   int m_score;  // 平均分
 };

 // 创建选手，并初始化姓名与分数
 void createPlayer(vector<person>& v)
 {
   string name_seed = "ABCDE"; // 名称种子
   for (int i = 0; i < 5; i++)
   {
     string name = "选手";
     name += name_seed[i];
     int score = 0; // 初始化分数
     person p(name, score); // 创建选手
     v.push_back(p); // 将选手插入到容器
   }
 }

注意，给选手打分有2种方法：

• 是手动输入，直接cin >> 10个分数

• 是直接随机数生成10个

我这里使用第二个方法

 // 打分并取均值，存储到选手属性中
 #include<ctime>// 获取系统时间的头文件
 void setScore(vector<person>& v)
 {
   srand((unsigned int)time(NULL)); // 随机数种子
   // 使用双头数组deque存储分数
   for (vector<person>::iterator it = v.begin(); it != v.end(); it++)
   {
     deque<int>d;
     //cout << "该选手分数分别为";
     for (int i = 0; i < 10; i++)
     {
       int score = rand() % 41 + 60; // 随机生成60-100之间的数
           //       0 - 40
       //cout << score << " ";
       d.push_back(score);
     }
     sort(d.begin(),d.end()); // 从小到大排序
     d.pop_front(); // 去除最小值
     d.pop_back();  // 去除最大值
     // 取平均分
     int sum = 0;
     int i = 10;
 ​
     for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
     {
       sum += *it; // 累加所有评委的打分
     }
     int avg = sum / d.size(); // 算出平均分
     it->m_score = avg; // 最外层循环，赋给选手的分数
     cout << endl;
   }
 }

 // 打印每位选手的姓名与分数
 void print2(const vector<person> v) // 加上const
 {
   for (vector<person>::const_iterator it = v.begin(); it != v.end(); it++)
   {     // 改成const_iterator
     cout << it->m_name << "分数为" << it->m_score << endl;
   }
   cout << endl;
 }

文章来源地址https://www.toymoban.com/news/detail-437809.html

到了这里，关于STL常用容器的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！