C++从入门到精通第十四章（STL容器）【上】

2026/9/13 8:28:39 拓冰建站浏览量

写在前面：

本系列专栏主要介绍C++的相关知识，思路以下面的参考链接教程为主，大部分笔记也出自该教程，笔者的原创部分主要在示例代码的注释部分。
除了参考下面的链接教程以外，笔者还参考了其它的一些C++教材（比如计算机二级教材和C语言教材），笔者认为重要的部分大多都会用粗体标注（未被标注出的部分可能全是重点，可根据相关部分的示例代码量和注释量判断，或者根据实际经验判断）。
如有错漏欢迎指出。

参考教程：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili

一、string容器

1、string容器概述

（1）string的本质：string是C++风格的字符串，而string本质上是一个类。

（2）string和char *的区别：char *是一个指针，而string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

（3）string 类内部封装了很多成员方法，例如查找find、拷贝copy、删除delete、替换replace、插入insert。

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

2、string类的构造函数

string();                //创建一个空的字符串（默认构造）

string(const string& str);   //使用一个string对象初始化另一个string对象（拷贝构造）

string(int n, char c);       //使用n个字符c初始化string对象

#include<iostream>
#include<string>
using namespace std;void test01()  
{string s1;      //默认构造const char * str = "Hello world";    //使用字符串初始化string s2(str);                      //这个也可视作拷贝构造cout << "s2 : " << s2 << endl;string s3(s2);   //拷贝构造cout << "s2 : " << s2 << endl;string s4(10, 'a');   //使用n个字符初始化cout << "s4 : " << s4 << endl;
}int main() {test01();system("pause");return 0;
}

3、string类的赋值操作

string& operator=(const char* s);     //把char*类型字符串赋值给当前的字符串

string& operator=(const string &s);   //把字符串s赋给当前的字符串

string& operator=(char c);          //把字符赋值给当前的字符串

string& assign(const char *s);       //把字符串s赋给当前的字符串

string& assign(const char *s, int n); //把字符串s的前n个字符赋给当前的字符串

string& assign(const string &s);     //把字符串s赋给当前的字符串

string& assign(int n, char c);        //用n个字符c组成字符串赋给当前的字符串

#include<iostream>
#include<string>
using namespace std;
#include<vector>void test01()   
{string str1;str1 = "Hello world";cout << "srt1 = " << str1 << endl;string str2;str2 = str1;cout << "srt2 = " << str2 << endl;string str3;str3 = 'a';cout << "srt3 = " << str3 << endl;string str4;str4.assign("Hello C++");cout << "srt4 = " << str4 << endl;string str5;str5.assign("Hello C++", 5);cout << "srt5 = " << str5 << endl;string str6;str6.assign(str5);cout << "srt6 = " << str6 << endl;string str7;str7.assign(10, 'w');cout << "srt7 = " << str7 << endl;
}int main() {test01();system("pause");return 0;
}

4、string字符串拼接函数

string& operator+=(const char* str); //重载+=操作符

string& operator+=(const char c);    //重载+=操作符

string& operator+=(const string& str); //重载+=操作符

string& append(const char *s);      //把字符串s连接到当前字符串结尾

string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾

string& append(const string &s);     //同operator+=(const string& str)

string& append(const string &s, int pos, int n);//字符串s中从pos开始的n个字符连接到字符串结尾

#include<iostream>
#include<string>
using namespace std;void test01()   
{string str1;str1 = "我";str1 += "爱玩游戏";cout << "str1 = " << str1 << endl;str1 += ':';cout << "str1 = " << str1 << endl;string str2 = " LOL DNF";str1 += str2;cout << "str1 = " << str1 << endl;string str3 = "I";str3.append(" love ");cout << "str3 = " << str3 << endl;str3.append("Python abcde", 6);cout << "str3 = " << str3 << endl;str3.append(str2);cout << "str3 = " << str3 << endl;str3.append(str2, 0, 4);     //参数2：从哪个位置开始截取cout << "str3 = " << str3 << endl;str3.append(str2, 4, 4);     //参数3：截取字符个数cout << "str3 = " << str3 << endl;
}int main() {test01();system("pause");return 0;
}

5、string类的查找和替换函数

查找指的是查找指定字符串是否存在，替换指的是在指定的位置替换字符串。

int find(const string& str, int pos = 0) const; //查找str第一次出现位置，从pos开始查找

int find(const char* s, int pos = 0) const;   //查找s第一次出现位置，从pos开始查找

int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置

int find(const char c, int pos = 0) const;     //查找字符c第一次出现位置

int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找

int rfind(const char* s, int pos = npos) const; //查找s最后一次出现位置,从pos开始查找

int rfind(const char* s, int pos, int n) const;   //从pos查找s的前n个字符最后一次位置

int rfind(const char c, int pos = 0) const;     //查找字符c最后一次出现位置

string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str

string& replace(int pos, int n,const char* s); //替换从pos开始的n个字符为字符串s

#include<iostream>
#include<string>
using namespace std;void test01()     //查找
{string str1 = "abcdefgcd";        //该字符串有两个“cd”int pos = str1.find("cd");      //find从左往右查if (pos == -1){cout << "未找到字符串" << endl;}else{cout << "pos = " << pos << endl;}pos = str1.find("df");if (pos == -1){cout << "未找到字符串" << endl;}else{cout << "pos = " << pos << endl;}pos = str1.rfind("cd");       //rfind从右往左查（位置编号还是从左往右算）cout << "pos = " << pos << endl;}void test02()     //替换
{string str1 = "abcdefg";str1.replace(2, 3, "kkkk");    //从2号位置起的3个字符替换为“kkkk”cout << "str1 = " << str1 << endl;
}int main() {test01();test02();system("pause");return 0;
}

6、string字符串比较函数

比较方式：字符串比较是从第一个字符开始，按字符的ASCII码进行对比，只要出现同位置字符ASCII码不同的情况，那么两个字符串就不相等，认为ASCII码较大的一个字符串更大。

①比较结果为“=”，返回0。

②比较结果为“>”，返回1。

③比较结果为“<”，返回-1。

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

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

#include<iostream>
#include<string>
using namespace std;string compare(string &str1,string &str2)
{if (str1.compare(str2) == 0){return " 等于= ";}else if (str1.compare(str2) == 1){return " 大于> ";}else if(str1.compare(str2) == -1){return " 小于< ";}
}void test01()     
{string str1 = "hello";string str2 = "hello";string str3 = "xello";string str4 = "heklo";cout << "str1" << compare(str1, str2) << "str2" << endl;cout << "str1" << compare(str1, str3) << "str3" << endl;cout << "str1" << compare(str1, str4) << "str4" << endl;
}int main() {test01();system("pause");return 0;
}

7、string字符串的字符存取

string字符串中单个字符存取方式有两种：

char& operator[](int n); //通过[]方式取字符

char& at(int n); //通过at方法获取字符

#include<iostream>
#include<string>
using namespace std;void test01()     
{string str = "Hello world";//通过[]访问单个字符for (int i = 0; i < str.size(); i++){cout << str[i] << " ";}cout << endl;str[0] = 'h';//通过at方式访问单个字符for (int i = 0; i < str.size(); i++){cout << str.at(i) << " ";}cout << endl;str.at(0) = 'H';for (int i = 0; i < str.size(); i++){cout << str.at(i) << " ";}cout << endl;
}int main() {test01();system("pause");return 0;
}

8、string字符串的字符插入和字符删除

对string字符串进行插入和删除操作时，要将string字符串视为字符数组，起始的下标都是从0开始算

string& insert(int pos, const char* s);     //插入字符串

string& insert(int pos, const string& str); //插入字符串

string& insert(int pos, int n, char c);      //在指定位置插入n个字符c

string& erase(int pos, int n = npos);      //删除从Pos开始的n个字符

#include<iostream>
#include<string>
using namespace std;void test01()     
{string str = "Hello";str.insert(1, "k2k");   //插入cout << "str = " << str << endl;str.erase(1, 3);        //删除cout << "str = " << str << endl;
}int main() {test01();system("pause");return 0;
}

9、从字符串string获取子串

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

#include<iostream>
#include<string>
using namespace std;void test01()     
{string str = "abcdefg";string subStr = str.substr(1, 3);cout << "subStr = " << subStr << endl;
}
void test02()
{string email = "zhangsan@sina.com";int pos = email.find("@");string usrName = email.substr(0, pos);cout << "usrName = " << usrName << endl;
}int main() {test01();test02();system("pause");return 0;
}

二、vector容器

1、vector的基本概念

（1）vector数据结构和数组非常相似，也称为单端数组。

（2）vector与普通数组区别：数组是静态空间，而vector可以动态扩展，而动态扩展并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。

（3）vector容器的迭代器是支持随机访问的迭代器。

2、vector的构造函数

vector<T> v;              //采用模板实现类实现，默认构造函数

vector(v.begin(), v.end());    //将v[begin(), end())区间中的元素拷贝给本身

vector(n, elem);           //构造函数将n个elem拷贝给本身

vector(const vector &vec); //拷贝构造函数

#include<iostream>
#include<vector>
using namespace std;void printVector(vector<int> &v)
{for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << "  ";}cout << endl;
}void test01()     
{vector<int> v1;                          //默认构造（无参构造）for (int i = 0; i < 10; i++){v1.push_back(i);}printVector(v1);vector<int> v2(v1.begin(), v1.end());    //通过区间方式进行构造printVector(v2);vector<int> v3(10, 199);                 //n个elem方式构造printVector(v3);vector<int> v4(v3);                      //拷贝构造printVector(v4);
}int main() {test01();system("pause");return 0;
}

3、vector的赋值操作

vector& operator=(const vector &vec); //重载等号操作符

assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身

assign(n, elem); //将n个elem拷贝赋值给本身

#include<iostream>
#include<vector>
using namespace std;void printVector(vector<int> &v)
{for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << "  ";}cout << endl;
}void test01()     
{vector<int> v1;for (int i = 0; i < 10; i++){v1.push_back(i);}printVector(v1);vector<int>v2;v2 = v1;          //赋值 operator=printVector(v2);vector<int>v3;v3.assign(v1.begin(), v1.end());   //赋值 assignprintVector(v3);vector<int>v4;v4.assign(10, 51);                 //赋值 n个elem方式printVector(v4);
}int main() {test01();system("pause");return 0;
}

4、vector的容量和大小

empty();       //判断容器是否为空

capacity();     //容器的容量

size();         //返回容器中元素的个数

resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置

//如果容器变短，则末尾超出容器长度的元素被删除

resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置

//如果容器变短，则末尾超出容器长度的元素被删除

#include<iostream>
#include<vector>
using namespace std;void printVector(vector<int> &v)
{for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << "  ";}cout << endl;
}void test01()     
{vector<int> v1,v2;if (v1.empty()){cout << "容器v1为空" << endl;}cout << endl;for (int i = 0; i < 10; i++){v1.push_back(i);}printVector(v1);if (v1.empty()){cout << "容器v1为空" << endl;}else{cout << "容器v1不为空" << endl;cout << "v1的容量为" << v1.capacity() << endl;cout << "v1的元素个数为" << v1.size() << endl;}v1.resize(15);printVector(v1);    //如果重新指定的长度比原来长了，默认用0填充新位置cout << "v1的容量为" << v1.capacity() << endl;cout << "v1的元素个数为" << v1.size() << endl;v2 = v1;v2.resize(8);printVector(v2);    //如果重新指定的长度比原来短，则超出长度的元素会被删除v2.resize(12, 10);printVector(v2);    //重新指定容器的长度，若容器变长，则以elem值填充新位置
}int main() {test01();system("pause");return 0;
}

5、vector的插入和删除

push_back(ele);                          //尾部插入元素ele

pop_back();                             //删除最后一个元素

insert(const_iterator pos, ele);              //迭代器指向位置pos插入元素ele

insert(const_iterator pos, int count,ele);      //迭代器指向位置pos插入count个元素ele

erase(const_iterator pos);                 //删除迭代器指向的元素

erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素

clear();                                //删除容器中所有元素

#include<iostream>
#include<vector>
using namespace std;void printVector(vector<int> &v)
{int j = 0;for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << "  ";j++;}if (j == 0){cout << "什么也没有" << endl;}cout << endl;
}void test01()     
{vector<int> v1;v1.push_back(10);  //尾插v1.push_back(20);v1.push_back(30);v1.push_back(40);v1.push_back(50);printVector(v1);v1.pop_back();    //尾删printVector(v1);v1.insert(v1.begin(), 100);   //插入  第一个参数是迭代器printVector(v1);v1.insert(v1.begin(), 2 ,100);printVector(v1);v1.erase(v1.begin());         //删除 参数是迭代器printVector(v1);v1.erase(v1.begin(), v1.end());   //v1.clear();具有同等作用printVector(v1);
}int main() {test01();system("pause");return 0;
}

6、vector的数据存取

at(int idx);   //返回索引idx所指的数据

operator[]; //返回索引idx所指的数据

front();     //返回容器中第一个数据元素

back();     //返回容器中最后一个数据元素

#include<iostream>
#include<vector>
using namespace std;void test01()     
{vector<int> v1;for (int i = 0; i < 10; i++){v1.push_back(i);}//利用[]方式访问数组元素for (int i = 0; i < v1.size(); i++){cout << v1[i] << " ";}cout << endl;//利用at方式访问元素for (int i = 0; i < v1.size(); i++){cout << v1.at(i) << " ";}cout << endl;cout << "第一个元素为： " << v1.front() << endl;cout << "最后一个元素为： " << v1.back() << endl;
}int main() {test01();system("pause");return 0;
}

7、vector的互换容器操作

swap(vec); //将vec中的元素与调用该函数的对象本身的元素互换

#include<iostream>
#include<vector>
using namespace std;void printVector(vector<int> &v)
{for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << "  ";}cout << endl;
}void test01()     
{cout << "交换前：" << endl;vector<int> v1;for (int i = 0; i < 10; i++){v1.push_back(i * 10);}printVector(v1);vector<int> v2;for (int i = 9; i > -1; i--){v2.push_back(i * 10);}printVector(v2);cout << "交换后：" << endl;v1.swap(v2);printVector(v1);printVector(v2);
}void test02()      //巧用swap可以收缩内存空间
{vector<int>v;for (int i = 0; i < 100000; i++){v.push_back(i);}cout << "v的容量为：" << v.capacity() << endl;cout << "v的大小为：" << v.size() << endl;v.resize(3);   //重新指定大小cout << "v的容量为：" << v.capacity() << endl;   //容量不会变小cout << "v的大小为：" << v.size() << endl;vector<int>(v).swap(v);            //vector<int>(v)--匿名对象，按照v的元素给它初始化，本行过后匿名对象被销毁cout << "v的容量为：" << v.capacity() << endl;   //容量变小cout << "v的大小为：" << v.size() << endl;
}int main() {test01();test02();system("pause");return 0;
}

8、vector允许预留空间

预留空间也就是先在内存划分一片属于vector对象的空间，这部分空间可以不立即使用，这样可以减少vector在动态扩展容量时的扩展次数。

reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问

#include<iostream>
#include<vector>
using namespace std;void test01()     
{vector<int> v;v.reserve(100000);   //预留空间int num = 0;    //统计开辟内存次数int *p = NULL;for (int i = 0; i < 100000; i++){v.push_back(i);if (p != &v[0]){p = &v[0];num++;}}cout << "num = " << num << endl;
}int main() {test01();system("pause");return 0;
}

三、deque容器

1、deque容器的基本概念

（1）deque容器是一个双端数组，可以对头端进行插入删除操作。

（2）deque与vector的区别：

①vector在头部插入或删除元素的效率低，数据量越大，效率越低。

②deque在头部插入元素或删除元素的速度比vector快。

③vector访问元素时的速度会比deque快，这和两者内部实现有关。

（3）deque内部的工作原理：

①deque内部有个中控器维护每段缓冲区中的内容，缓冲区中存放真实数据。

②中控器维护的是每个缓冲区的地址，使得使用deque时像是使用一片连续的内存空间。

（4）deque容器的迭代器也是支持随机访问的。

2、deque的构造函数

deque<T> deqT;           //默认构造形式

deque(beg, end);          //构造函数将[beg, end)区间中的元素拷贝给本身

deque(n, elem);           //构造函数将n个elem拷贝给本身

deque(const deque &deq); //拷贝构造函数

#include<iostream>
#include<deque>
using namespace std;void printDeque(const deque<int> &d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){//*it = 100;   容器中的数据不可以修改了cout << *it << "  ";}cout << endl;
}void test01()     
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);}printDeque(d1);deque<int>d2(d1.begin(), d1.end());printDeque(d2);deque<int>d3(10, 100);printDeque(d3);deque<int>d4(d3);printDeque(d4);
}int main() {test01();system("pause");return 0;
}

3、deque的赋值操作

deque& operator=(const deque &deq); //重载等号操作符

assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身

assign(n, elem); //将n个elem拷贝赋值给本身

#include<iostream>
#include<deque>
using namespace std;void printDeque(const deque<int> &d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){cout << *it << "  ";}cout << endl;
}void test01()     
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);}printDeque(d1);//operator=赋值deque<int>d2;d2 = d1;printDeque(d2);//assign赋值deque<int>d3;d3.assign(d1.begin(), d1.end());printDeque(d3);//n个elem方式赋值deque<int>d4(10, 100);printDeque(d4);
}int main() {test01();system("pause");return 0;
}

4、deque的大小

deque.empty(); //判断容器是否为空

deque.size(); //返回容器中元素的个数

deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置

//如果容器变短，则末尾超出容器长度的元素被删除。

deque.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置

//如果容器变短，则末尾超出容器长度的元素被删除

#include<iostream>
#include<deque>
using namespace std;void printDeque(const deque<int> &d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){cout << *it << "  ";}cout << endl;
}void test01()     
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);}printDeque(d1);if (d1.empty()){cout << "容器d1为空" << endl;}cout << "d1中的元素个数为：" << d1.size() << endl;   //deque没有“容量”的概念d1.resize(15);printDeque(d1);d1.resize(8);printDeque(d1);d1.resize(15, 1);printDeque(d1);
}int main() {test01();system("pause");return 0;
}

5、deque的插入和删除

//两端的插入操作：

push_back(elem);   //在容器尾部添加一个数据

push_front(elem);   //在容器头部插入一个数据

pop_back();        //删除容器最后一个数据

pop_front();        //删除容器第一个数据

//指定位置操作：

insert(pos,elem);      //在pos位置插入一个elem元素的拷贝，返回新数据的位置

insert(pos,n,elem);    //在pos位置插入n个elem数据，无返回值

insert(pos,beg,end);   //在pos位置插入[beg,end)区间的数据，无返回值

clear();              //清空容器的所有数据

erase(beg,end);       //删除[beg,end)区间的数据，返回下一个数据的位置

erase(pos);          //删除pos位置的数据，返回下一个数据的位置

#include<iostream>
#include<deque>
using namespace std;void printDeque(const deque<int> &d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){cout << *it << "  ";}cout << endl;
}void test01()     
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);      //尾插d1.push_front(i * 2); //头插}printDeque(d1);d1.pop_back();printDeque(d1);d1.pop_front();printDeque(d1);
}
void test02()
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);}d1.insert(d1.begin(), 30);printDeque(d1);d1.insert(d1.begin(), 2, 40);printDeque(d1);deque<int>d2;for (int i = 0; i < 10; i++){d2.push_front(i);}d1.insert(d1.begin()+1, d2.begin(), d2.end());printDeque(d1);
}
void test03()
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);}d1.erase(++d1.begin());printDeque(d1);d1.erase(d1.begin(), d1.end());   //d1.clear();具有同等作用printDeque(d1);
}int main() {test01();cout << endl;test02();cout << endl;test03();system("pause");return 0;
}

6、deque的数据存取

at(int idx); //返回索引idx所指的数据

operator[]; //返回索引idx所指的数据

front(); //返回容器中第一个数据元素

back(); //返回容器中最后一个数据元素

#include<iostream>
#include<deque>
using namespace std;void test01()     
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);      //尾插d1.push_front(i * 2); //头插}//通过[]方式访问元素for (int i = 0; i < d1.size(); i++){cout << d1[i] << " ";}cout << endl;//通过at方式访问元素for (int i = 0; i < d1.size(); i++){cout << d1.at(i) << " ";}cout << endl;cout << "第一个元素为：" << d1.front() << endl;cout << "最后一个元素为：" << d1.back() << endl;
}int main() {test01();system("pause");return 0;
}

7、deque的数据排序算法

sort(iterator beg, iterator end) //对beg和end区间内元素进行排序

#include<iostream>
#include<deque>
#include<algorithm>
using namespace std;void printDeque(const deque<int> &d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){cout << *it << "  ";}cout << endl;
}void test01()     
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);      //尾插d1.push_front(i * 2); //头插}printDeque(d1);sort(d1.begin(),d1.end());   //升序排序//对于支持随机访问的迭代器的容器，都可以用sort算法直接对其进行排序//vector容器也可以利用sort进行排序printDeque(d1);
}int main() {test01();system("pause");return 0;
}

8、案例

（1）案例描述：有5名选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。

（2）实现步骤：

①创建五名选手，放到vector中。

②遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中。

③sort算法对deque容器中分数排序，去除最高和最低分。

④deque容器遍历一遍，累加总分。

⑤获取平均分。

（3）代码：

#include<iostream>
#include<deque>
#include<vector>
#include<algorithm>
#include<string>
#include<time.h>
using namespace std;/* 案例描述：有5名选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分
实现步骤：
创建五名选手，放到vector中
遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
sort算法对deque容器中分数排序，去除最高和最低分
deque容器遍历一遍，累加总分
获取平均分*/class Person
{
public:Person(int score, string name){m_name = name;m_score = score;}int m_score;string m_name;
};
void createPerson(vector<Person>&v)
{string nameSeed = "ABCDE";for (int i = 0; i < 5; i++){string name = "player_";name += nameSeed[i];int score = 0;Person p(score, name);v.push_back(p);}
}
void setScore(vector<Person>&v)
{for (vector<Person>::iterator it = v.begin(); it != v.end(); it++){deque<int>d;for (int i = 0; i < 10; i++){int score = rand() % 51 + 50;   //int score = [rand() % 51] + 50; []内取值为0~50d.push_back(score);}sort(d.begin(),d.end());d.pop_back();d.pop_front();int sum = 0;for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++){sum += *dit;}int avg = sum / d.size();it->m_score = avg;}
}void func()     
{vector<Person>p;createPerson(p);setScore(p);for (vector<Person>::iterator it = p.begin(); it != p.end(); it++){cout << it->m_name << "的最终得分为" << it->m_score << endl;}
}int main() {srand((unsigned int)time(NULL));func();system("pause");return 0;
}

五、stack容器

1、stack的基本概念

（1）stack是一种先进后出（First In Last Out，FILO）的数据结构，它只有一个出口。

（2）栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。

（1）栈中进入数据的过程称为入栈（push），栈中弹出数据的过程称为出栈（pop）。

2、stack的常用接口

//构造函数：

stack<T> stk;          //stack采用模板类实现，stack对象的默认构造形式

stack(const stack &stk); //拷贝构造函数

//赋值操作：

stack& operator=(const stack &stk);   //重载等号操作符

//数据存取：

push(elem);   //向栈顶添加元素

pop();        //从栈顶移除第一个元素

top();        //返回栈顶元素

//大小操作：

empty();      //判断堆栈是否为空

size();        //返回栈的大小

#include<iostream>
#include<stack>
using namespace std;void test01()     
{stack<int>s;    //符合先进后出的数据结构s.push(10);     //入栈s.push(20);s.push(30);s.push(40);while (!s.empty())   //只要栈不为空，查看栈顶，并执行出栈操作{cout << "栈顶元素为：" << s.top() << endl;s.pop();    //出栈}cout << "现在栈的大小为：" << s.size() << endl;
}int main() {test01();system("pause");return 0;
}

六、queue 容器

1、queue的基本概念

（1）Queue是一种先进先出（First In First Out，FIFO）的数据结构，它有两个出口。

（2）队列容器允许从一端（队尾）新增元素，从另一端（队头）移除元素。

（3）队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为。

（4）数据进入队列中的过程称为入队（push），数据从队列中被移出的过程称为出队（pop）。

2、queue的常用接口

//构造函数：

queue<T> que;             //queue采用模板类实现，queue对象的默认构造形式

queue(const queue &que);   //拷贝构造函数

//赋值操作：

queue& operator=(const queue &que); //重载等号操作符

//数据存取：

push(elem);   //往队尾添加元素

pop();        //从队头移除第一个元素

back();       //返回最后一个元素

front();       //返回第一个元素

//大小操作：

empty();     //判断堆栈是否为空

size();       //返回栈的大小

#include<iostream>
#include<queue>
using namespace std;class Person
{
public:int age1;int age2;Person(int age1, int age2){this->age1 = age1;this->age2 = age2;}
};void test01()     
{queue<Person>q;       //创建队列Person p1(10, 18);    //准备数据Person p2(20, 38);Person p3(30, 58);Person p4(40, 28);q.push(p1);           //入队q.push(p2);q.push(p3);q.push(p4);cout << "队列大小为：" << q.size() << endl;while (!q.empty()){cout << "队头为： age1 = " << q.front().age1 << "  age2 = " << q.front().age2 << endl;cout << "队尾为： age1 = " << q.back().age1 << "  age2 = " << q.back().age2 << endl;cout << endl;q.pop();          //出队}cout << "队列大小为：" << q.size() << endl;
}int main() {test01();system("pause");return 0;
}

建站实战干货

C++从入门到精通 第十四章（STL容器）【上】