写在前面：
- 本系列专栏主要介绍C++的相关知识，思路以下面的参考链接教程为主，大部分笔记也出自该教程，笔者的原创部分主要在示例代码的注释部分。
- 除了参考下面的链接教程以外，笔者还参考了其它的一些C++教材（比如计算机二级教材和C语言教材），笔者认为重要的部分大多都会用粗体标注（未被标注出的部分可能全是重点，可根据相关部分的示例代码量和注释量判断，或者根据实际经验判断）。
- 由于C++基本继承了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()); //赋值 assign
printVector(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~50
d.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;
}
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
