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 = 30
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;
}输出结果：
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 20
printDeque(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 20
printDeque(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 20
printDeque(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 30
printDeque(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 ~ 100
d.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
请按任意键继续. . .
