C++提高笔记（三）---STL容器（vector、deque）-编程知识

1、vector容器

1.1vector基本概念

功能：vector数据结构和数组非常相似，也称为单端数组

vector与普通数组区别：不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

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

1.2vector构造函数

功能描述：创建vector容器

函数原型：

vector<T> v;                //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v［begin(),end() )区间中的元素拷贝给本身
vector(n, elem);            // 构造函数将n个elem拷贝给本身
vector(const vector& vec);  //拷贝构造函数

#include <iostream>
using namespace std;
#include<vector>
//vector构造函数：
//vector<T> v;                //采用模板实现类实现，默认构造函数
//vector(v.begin(), v.end()); //将v［begin(),end() )区间中的元素拷贝给本身
//vector(n, elem);            // 构造函数将n个elem拷贝给本身
//vector(const vector& vec);  //拷贝构造函数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);//n个elem方式构造vector<int>v3(6, 100);printVector(v3);//拷贝构造vector<int>v4(v3);printVector(v4);
}int main()
{test01();system("pause");return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100
100 100 100 100 100 100
请按任意键继续. . .

1.3vector赋值操作

功能描述：给vector容器进行赋值

函数原型：

vector& operator=(const vector& vec); //重载等号操作符
assign(beg, end);                     //将［beg，end ) 区间中的数据拷贝赋值给本身
assign(n, elem);                      //将n个elem拷贝赋值给本身

#include <iostream>
using namespace std;
#include<vector>
//vector赋值操作：
//vector& operator=(const vector& vec); //重载等号操作符
//assign(beg, end);                     //将［beg，end ) 区间中的数据拷贝赋值给本身
//assign(n, elem);                      //将n个elem拷贝赋值给本身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);//赋值 operator=vector<int>v2;v2 = v1;printVector(v2);//assign赋值vector<int>v3;v3.assign(v1.begin(), v1.end());printVector(v3);//n个elem方式赋值vector<int>v4;v4.assign(10, 100);printVector(v4);
}int main()
{test01();system("pause");return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100 100 100 100 100
请按任意键继续. . .

1.4vector容量和大小

功能描述：对vector容器的容量和大小操作

函数原型：

empty();                //判断容器是否为空
capacity();             //容器的容量
size();                 //返回容器中元素的个数
resize(int num);        //重新指定容器的长度为num，若容器变长，则以默认值填充新位置//如果容器变短，则未尾超出容器长度的元素被删除
resize(int num, elem);  //重新指定容器的长度为num，若容品变长，则以elem值填充新位置//如果容器变短，则未尾超出容器长度的元素被删除

#include <iostream>
using namespace std;
#include<vector>
// vector容器的容量和大小操作
//empty();                //判断容器是否为空
//capacity();             //容器的容量
//size();                 //返回容器中元素的个数
//resize(int num);        //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
//                        //如果容器变短，则未尾超出容器长度的元素被删除
//resize(int num, elem);  //重新指定容器的长度为num，若容品变长，则以elem值填充新位置
//                        //如果容器变短，则未尾超出容器长度的元素被删除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);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填充新的位置//也可以指定默认填充值v1.resize(15,100);printVector(v1);v1.resize(5);//若重新指定的容器变短了，未尾超出容器长度的元素被删除printVector(v1);}
}int main()
{test01();system("pause");return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9
v1不为空
v1的容量为：13
v1的大小为：10
0 1 2 3 4 5 6 7 8 9 100 100 100 100 100
0 1 2 3 4
请按任意键继续. . .

1.5vector插入和删除

功能描述：对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>
using namespace std;
#include<vector>
//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();                                         //删除容器中所有元素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;//尾插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, 90);printVector(v1);//删除 第一个参数是迭代器v1.erase(v1.begin());printVector(v1);//清空v1.clear();//与下句代码等价v1.erase(v1.begin(), v1.end());printVector(v1);
}int main()
{test01();system("pause");return 0;
}

输出结果：

10 20 30 40 50
10 20 30 40
100 10 20 30 40
90 90 100 10 20 30 40
90 100 10 20 30 40请按任意键继续. . .

1.6vector数据存取

功能描述：对vector中的数据的存取操作

函数原型：

at(int idx);//返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front();    //返回容器中第一个数据元素
back();     //返回容器中最后一个数据元素

#include <iostream>
using namespace std;
#include<vector>
//vector容器数据存取//at(int idx);//返回索引idx所指的数据
//operator[]; //返回索引idx所指的数据
//front();    //返回容器中第一个数据元素
//back();     //返回容器中最后一个数据元素            
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;
}

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
第一个元素为: 0
最后一个元素为: 9
请按任意键继续. . .

1.7vector互换容器

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

函数原型：

swap(vec); //将vec与本身的元素互换

#include <iostream>
using namespace std;
#include<vector>
//vector容器互换
//swap(vec); //将vec与本身的元素互换   //1、基本使用
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);}cout << "交换前：" << endl;printVector(v1);vector<int>v2;for (int i = 10; i > 0; i--){v2.push_back(i);}printVector(v2);cout << "交换后：" << endl;v1.swap(v2);printVector(v1);printVector(v2);
}
//2、实际用途
//巧用swap可以收缩内存空间
void test02()
{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;//巧用swap收缩内存空间//vector<int>(v)是一个匿名对象//.swap(v)做了一个容器之间的交换vector<int>(v).swap(v);cout << "v的容量为：" << v.capacity() << endl;cout << "v的大小为：" << v.size() << endl;
}int main()
{test01();test02();system("pause");return 0;
}

输出结果：

交换前：
0 1 2 3 4 5 6 7 8 9
10 9 8 7 6 5 4 3 2 1
交换后：
10 9 8 7 6 5 4 3 2 1
0 1 2 3 4 5 6 7 8 9
v的容量为：138255
v的大小为：100000
v的容量为：138255
v的大小为：3
v的容量为：3
v的大小为：3
请按任意键继续. . .

1.8vector预留空间

功能描述：减少vector在动态扩展容量时的扩展次数

函数原型：

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

#include <iostream>
using namespace std;
#include<vector>
//vector预留空间
//reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问
void test01()
{vector<int>v;//利用reserve预留空间v.reserve(100000);//没有这句代码时，num = 30int 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;
}

输出结果：

num = 1
请按任意键继续. . .

总结：如果数据量较大，可以一开始利用reserve预留空间

2、deque容器

2.1deque容器基本概念

功能：双端数组，可以对头端进行插入删除操作

deque与vector区别：
• vector对于头部的插入删除效率低，数据量越大，效率越低
• deque相对而言，对头部的插入删除速度会比vector快
• vector访问元素时的速度会比deque快，这和两者内部实现有关

deque内部工作原理：

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

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

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

2.2deque构造函数

功能描述：deque容器构造

函数原型：

deque<T>deqT;            //默认构造形式
deque(beg, end);         //构造函数将［beg, end）区间中的元素拷贝给本身
deque(n, elem);          //构造函数将n个elem拷贝给本身
deque(const deque& deq); //拷贝构造函数

下面的代码有一部分介绍了如何把容器变为只读状态（看注释）！！

#include <iostream>
using namespace std;
#include<deque>
//deque构造函数
//deque<T>deqT;            //默认构造形式
//deque(beg, end);         //构造函数将［beg, end）区间中的元素拷贝给本身
//deque(n, elem);          //构造函数将n个elem拷贝给本身
//deque(const deque& deq); //拷贝构造函数void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){//函数参数列表里的const和for循环条件里的const_把容器变为了只读状态//*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(6, 100);printDeque(d3);deque<int>d4(d3);printDeque(d4);
}int main()
{test01();system("pause");return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100
100 100 100 100 100 100
请按任意键继续. . .

总结：deque容器与vector容器的构造方式几乎一致，灵活使用即可

2.3deque赋值操作

功能描述：给deque容器进行赋值

函数原型：

deque& operator=(const deque& deq); //重载等号操作符
assign(beg, end);                   //将［beg, end）区间中的数据拷贝赋值给本身
assign(n, elem);                    //将n个elem拷贝赋值给本身

#include <iostream>
using namespace std;
#include<deque>
//deque容器赋值操作
//deque& operator=(const deque& deq); //重载等号操作符
//assign(beg, end);                   //将［beg, end）区间中的数据拷贝赋值给本身
//assign(n, elem);                    //将n个elem拷贝赋值给本身
void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){//函数参数列表里的const和for循环条件里的const_把容器变为了只读状态//*it = 100;  容器中的数据不可以修改了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);deque<int>d4;d4.assign(6, 100);printDeque(d4);
}int main()
{test01();system("pause");return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
100 100 100 100 100 100
请按任意键继续. . .

2.4deque大小操作

功能描述：对deque容器的大小进行操作

函数原型：

deque.empty();                //判断容器是否为空
deque.size();                 //返回容器中元素的个数
deque.resize(int num);        //重新指定容器的长度为num，若容器变长，则以默认值填充新位置//如果容器变短，则未尾超出容器长度的元素被删除
deque.resize(int num, elem);  //重新指定容器的长度为num，若容品变长，则以elem值填充新位置//如果容器变短，则未尾超出容器长度的元素被删除

deque没有容量的概念

#include <iostream>
using namespace std;
#include<deque>
//deque容器大小操作
//deque.empty();                //判断容器是否为空
//deque.size();                 //返回容器中元素的个数
//deque.resize(int num);        //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
//                              //如果容器变短，则未尾超出容器长度的元素被删除
//deque.resize(int num, elem);  //重新指定容器的长度为num，若容品变长，则以elem值填充新位置
//                              //如果容器变短，则未尾超出容器长度的元素被删除
void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){//函数参数列表里的const和for循环条件里的const_把容器变为了只读状态//*it = 100;  容器中的数据不可以修改了cout << *it << " ";}cout << endl;
}void test01()
{deque<int>d1;for (int i = 0; i < 10; i++){d1.push_back(i);}  if (d1.empty()){cout << "d1为空" << endl;}else{cout << "d1不为空" << endl;cout << "d1的大小为：" << d1.size() << endl;//deque没有容量的概念}printDeque(d1);//重新指定大小  变长d1.resize(12,1);printDeque(d1);//重新指定大小  变短d1.resize(5);printDeque(d1);
}int main()
{test01();system("pause");return 0;
}

输出结果：

d1不为空
d1的大小为：10
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9 1 1
0 1 2 3 4
请按任意键继续. . .

2.5deque插入和删除

功能描述：向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>
using namespace std;
#include<deque>
//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位置的数据，返回下一个数据的位置void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){//函数参数列表里的const和for循环条件里的const_把容器变为了只读状态//*it = 100;  容器中的数据不可以修改了cout << *it << " ";}cout << endl;
}
//两端操作
void test01()
{cout << "test01测试输出:" << endl;deque<int>d1;//尾插d1.push_back(10);d1.push_back(20);//头插d1.push_front(100);d1.push_front(200);//200 100 10 20printDeque(d1);//尾删d1.pop_back();printDeque(d1);//头删d1.pop_front();printDeque(d1);
}void test02()
{cout << "test02测试输出:" << endl;deque<int>d1;//尾插d1.push_back(10);d1.push_back(20);//头插d1.push_front(100);d1.push_front(200);//200 100 10 20printDeque(d1);//insert 插入d1.insert(d1.begin(), 90);printDeque(d1);d1.insert(d1.begin(), 2, 80);printDeque(d1);//按照区间进行插入deque<int>d2;d2.push_back(1);d2.push_back(2);d2.push_back(3);d1.insert(d1.begin(), d2.begin(), d2.end());printDeque(d1);
}void test03()
{cout << "test03测试输出:" << endl;deque<int>d1;d1.push_back(10);d1.push_back(20);d1.push_front(100);d1.push_front(200);printDeque(d1);//删除第一个元素  很简单 注释掉了//d1.erase(d1.begin());//printDeque(d1);//删除第二个元素deque<int>::iterator it = d1.begin();it++;d1.erase(it);//200 10 20printDeque(d1);//按区间方式删除d1.erase(d1.begin(), d1.end());//等价于//d1.clear();printDeque(d1);
}int main()
{test01();test02();test03();system("pause");return 0;
}

输出结果：

test01测试输出:
200 100 10 20
200 100 10
100 10
test02测试输出:
200 100 10 20
90 200 100 10 20
80 80 90 200 100 10 20
1 2 3 80 80 90 200 100 10 20
test03测试输出:
200 100 10 20
200 10 20请按任意键继续. . .

总结：插入和删除提供的位置是迭代器

2.6deque数据存取

功能描述：对deque中的数据的存取操作

函数原型：

at(int idx); //返回索引idx所指的数据
operator[];  //返回索引idx所指的数据
front();     //返回容器中第一个数据元素
back();      //返回容器中最后一个数据元素

#include <iostream>
using namespace std;
#include<deque>
//deque容器数据存取
//at(int idx); //返回索引idx所指的数据
//operator[];  //返回索引idx所指的数据
//front();     //返回容器中第一个数据元素
//back();      //返回容器中最后一个数据元素
void test01()
{deque<int>d;d.push_back(10);d.push_back(20);d.push_back(30);d.push_front(100);d.push_front(200);d.push_front(300);//300 200 100 10 20 30//通过[]方式访问元素for (int i = 0; i < d.size(); i++){cout << d[i] << " ";}cout << endl;//通过at方式访问元素for (int i = 0; i < d.size(); i++){cout << d.at(i) << " ";}cout << endl;cout << "第一个元素为：" << d.front() << endl;cout << "最后一个元素为：" << d.back() << endl; 
}int main()
{test01();system("pause");return 0;
}

输出结果：

300 200 100 10 20 30
300 200 100 10 20 30
第一个元素为：300
最后一个元素为：30
请按任意键继续. . .

2.7deque排序

功能描述：利用算法实现对deque容器进行排序

算法：

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

默认排序规则：从小到大升序
对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
vector容器也可以利用sort进行排序

#include <iostream>
using namespace std;
#include<deque>
#include<algorithm>//标准算法头文件
//deque排序
//sort(iterator beg, iterator end);//对beg和end区间内元素进行排序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>d;d.push_back(10);d.push_back(20);d.push_back(30);d.push_front(100);d.push_front(200);d.push_front(300);//300 200 100 10 20 30printDeque(d);//排序 默认排序规则：从小到大 升序//对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序//vector容器也可以利用sort进行排序sort(d.begin(), d.end());cout << "排序后：" << endl;printDeque(d);
}int main()
{test01();system("pause");return 0;
}

输出结果：

300 200 100 10 20 30
排序后：
10 20 30 100 200 300
请按任意键继续. . .

3、案例---评委打分

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

实现步骤：
1、创建五名选手，放到vector中
2、遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中 3、sort算法对deque容器中分数排序，去除最高和最低分
4、deque容器遍历一遍，累加总分
5、获取平均分

#include <iostream>
using namespace std;
#include<deque>
#include<vector>
#include<algorithm>//标准算法头文件
#include<string>
#include<ctime>
/*
有5名选手:选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分
*/
//选手类
class Person
{
public:Person(string name, int score){this->m_Name = name;this->m_Score=score;}string m_Name;//姓名int m_Score;//平均分
};void creatPerson(vector<Person>& v)
{string nameSeed = "ABCDE";for (int i = 0; i < 5; i++){string name = "选手";name += nameSeed[i];int score = 0;Person p(name, score);//将创建的Person对象 放入到容器中v.push_back(p);}
}void setScore(vector<Person>& v)
{for (vector<Person>::iterator it = v.begin(); it != v.end(); it++){//将评委的分数 放入到deque容器中deque<int>d;for (int i = 0; i < 10; i++){int score = rand() % 41 + 60;  // 60 ~ 100d.push_back(score);}//测试程序 观察每个选手的得分情况//但是没有加入随机数种子，所以每个选手的得分不会变化/*cout << "选手：" << it->m_Name << "得分：" << endl;for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++){cout << (*dit) << " ";}cout << endl;*///排序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 showScore(vector<Person>& v)
{for (vector<Person>::iterator it = v.begin(); it != v.end(); it++){cout << "姓名：" << (*it).m_Name << " 平均分：" << (*it).m_Score << endl;}
}int main()
{//创建随机数种子//这样每次产生的得分就会不同//srand((unsigned int)time(NULL));//1、创建5名选手vector<Person>v;//存放选手容器creatPerson(v);//测试/*for (vector<Person>::iterator it = v.begin(); it != v.end(); it++){cout << "姓名：" << (*it).m_Name << "分数：" << (*it).m_Score << endl;}*///2、给5名选手打分setScore(v);//3、显示最后得分showScore(v);system("pause");return 0;
}

输出结果：

姓名：选手A 平均分：78
姓名：选手B 平均分：82
姓名：选手C 平均分：74
姓名：选手D 平均分：80
姓名：选手E 平均分：77
请按任意键继续. . .