C++系统学习(STL初识容器)

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<algorithm>  //标准算法头文件
#include<ctime>

/*初识STL

*STL： （Standard Template Library）标准模板库
*STL 从广义上分为: 容器（container）算法（algorithm）迭代器（iterator）
*容器和算法之间通过迭代器进行无缝连接
*STL几乎所有的代码都采用了模板类或者模板函数

*/


/*STL六大组件

STL大体分为六大组件：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

1.容器 ：各种数据结构 ,如 vector 、list 、deque 、set 、map等用来存放数据

2.算法 :各种常用的算法 ，如sort、find、copy、for_each等

3.迭代器 : 扮演了容器与算法之间的胶合剂    使用类似指针

4.仿函数 : 行为类似函数，可作为算法的某种策略       -重载小括号()      学习注重前1-4点

5.适配器 :一种用来修饰容器或者仿函数或迭代器接口的东西

6.空间配置器 :负责空间的配置与管理


*/

void myPrint(int val){
	cout << val << endl;
}

void test_cointainor01()
{

	//创建了一个vector容器，数组
	vector<int> v; //每种容器都需要对应的头文件 

	//向容器中插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	//通过迭代器访问容器中的数据
	vector<int>::iterator itBegin = v.begin();  //v.begin()起始迭代器 指向容器第一个元素
	vector<int>::iterator itEnd = v.end();   //v.end()结束迭代器 指向容器最后一个元素的下一个位置
	
	//第一种的遍历方式
	while (itBegin != itEnd)
	{
		cout<< *itBegin <<endl;
		itBegin++;
	}
	
	//第二种遍历方式
	for (vector<int>::iterator it = v.begin(); it != v.end() ; it++)
	{
		cout << *it << endl;
	}

	//第一种的遍历方式 STL提供的遍历算法
	for_each(v.begin(), v.end(), myPrint);//回调技术  观看底层for循环的函数返回

}

//Vector存放自定义数据类型
class Person {

public:
	Person(string name,int age) {
		m_Name = name;
		m_Age = age;
	}
	string m_Name;
	int m_Age;
};

void testVector_01() {

	vector<Person*>v;   //Person   、 Person*型
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	//向容器中添加数据
	v.push_back(&p1);//&p1  -- Person*型   、   p1 --Person型
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);

	//遍历容器的数据


	/*
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		//cout << "姓名 ： " << (*it).m_Name << "  年龄 ： " << (*it).m_Age << endl;  //解引用后点出来也行
		cout<< "姓名 ： "<< it->m_Name<<"  年龄 ： " <<  it->m_Age << endl;
	}
	*/

	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) 
	{
		//Person* 解引用是一个指针，解出来后拿其所属性要用->
		cout << "姓名 ： " << (*it)->m_Name << "  年龄 ： " << (*it)->m_Age << endl;
	}
}

//vector容器嵌套

void for_for() 
{
	vector< vector<int>>v;

	//创建小容器
	vector<int > v1;
	vector<int > v2;
	vector<int > v3;
	vector<int > v4;


	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v1.push_back(i + 2);
		v1.push_back(i + 3);
		v1.push_back(i + 4);

	}

	//将小容器插入到大容器中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);

	//通过大容器把所有的数据遍历一遍
	for (vector< vector<int>>::iterator it = v.begin(); it != v.end();it++)
	{
		// (*it) == 容器 vector<int>
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)//每个小容器输出
		{
			cout<< *vit << " " ;//?换行?
		}
		cout << endl; //换行   每次换行集中在了最后？

	}
}

/*string 的基本概念
string 是C++风格的字符串，本质是一个类

string 与 char*的区别

char* 是一个指针 ，string是一个类，类内部封装了char* ，管理这个字符串，是一个char*型的容器

特点:

string类内部封装了很多成员函数方法

例如： 查找find，拷贝copy ，删除delete ， 替换replace  ，插入insert
string管理char*所分配的内存，不用担心复制和取值越界的问题，由类内部进行负责

string构造函数
1. string();					//创建一个空字符串 ，例如：string str;
2. string(const char* s);		//使用字符串s初始化
3. string(const string &str);	//使用一个string对象初始化另一个string对象
4. string(int n,char c);		//使用n个字符c初始化   ，赋值n个连续的c
*/

void test_String_01()
{
	string s1;//默认构造

	const char* str = "hello world";
	string s2(str);//传参构造

	cout<< "s2 = " << s2 <<endl;

	string s3(s2);//拷贝构造
	cout << "s3 = " << s3 << endl;

	string s4(10, 'a');
	cout << "s4 = " << s4 << endl;
}


/*string赋值操作
功能描述：
给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);  //字符串前n个赋值
string assign=(const string& s);		//把字符串s赋值给当前字符串
string assign=(int n,char c);		//把n个字符c赋值

*/

void test___01() {
	string str1;
	str1 = "hello world";
	
	cout << "str1 = " << str1 << endl;

	string str2;
	str2 = str1;
	
	cout << "str2 = " << str2 << endl;
	string str3;
	str3 = 'a';
	cout<< "str3 = "  << str3  <<endl;

	string str4;
	str4.assign("hello C++");
	cout << "str4 = " << str4 << endl;

	string str5;
	str5.assign("hello C++", 5);
	cout << "str5 = " << str5 << endl;

	string str6;
	str6.assign(str5);
	cout << "str6 = " << str6 << endl;

	string str7;
	str7.assign(10,'w');
	cout << "str7 = " << str7 << endl;


}

/*string 字符串拼接
实现在字符串末尾拼接字符串

string& operator+=(const char* str);		//重载+=操作符
string& operator+=(const char c);			//重载+=操作符
string& operator+=(char string& str);		//重载+=操作符
string& assign+=(const char* s);			//把字符串s拼接到当前字符串结尾
string& assign+=(const char* s,int n);		//字符串s的前n个字符拼接到当前字符串结尾
string& assign+=(const string& s);			//把字符串s拼接到当前字符串结尾
string& assign+=(const string& s,int pos ,int n);  //把字符串s从pos开始的n个字符连接到字符串结尾


*/

void test_joint() {
	string 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("game bacde",4);
	cout << "str3 = " << str3 << endl;

	

	str3.append(str2,0,3);  //*从第n个位置开始截取，截取m个
	cout << "str3 = " << str3 << endl;  

	str3.append(str2,3,4);	//*从第n个位置开始截取，截取m个
	cout << "str3 = " << str3 << endl;

	
}

/*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* s ,int pos ,int n) 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


*/

//查找
void test_find_01() {
	string str1 = "abcdefg";

	int pos = str1.find("de");

	if (pos == -1)
	{
		cout << "未找到字符串"<< endl;
	}
	else
	{
		cout << "find : de 's pos = " << pos << endl;
	}
	
	//rfind 与find的区别
	//rfind从右往左查找，find从左往右查找

	pos = str1.rfind("de");
	cout << "rfind : de 's pos = " << pos << endl;
}

//替换
void test_substitute_01()
{
	string str1 = "abcdefg";

	//从1号位置起 3个字符 替换为"1111"
	str1.replace(1, 3, "1111");

	cout<< "str1 = "<< str1 <<endl;
}

/*string字符串比较
字符串之间的比较

按ASCLL码进行比较

= 返回  0

> 返回  1

< 返回 -1

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

*/

void test_string_compare() {  //主要用于比较字符串是否相等
	string str1 = "hello  ";
	string str2 = "hello ";

	if (str1.compare(str2) == 0)
	{
		cout<< "str1 等于 str2" <<endl;
	}
	else if(str1.compare(str2) < 0)
	{
		cout << "str1 小于 str2" << endl;
	}
	else
	{
		cout << "str1 大于 str2" << endl;
	}
}

/*string 字符获取

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

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

void test_get_string() {
	string str = "hello";


	//cout<<  "str = "<< str <<endl;

	//1.通过下标[]方式获取字符
	for (int i = 0;i < str.size();i++)
	{
		cout << str[i] <<" ";
	}
	cout << endl;

	//通过at方法获取字符
	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;

	//修改单个字符
	str[0] = 'x'; //xello
	cout<< str <<endl;

	str[1] = 'x'; //xxllo
	cout<< str <<endl;
}

/*string插入和删除

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个字符

*/

void test_string_del_and_insert() 
{
	string str = "hello";

	//插入
	str.insert(1, "111");
	//h111ello
	cout<<"str = " << str <<endl;

	//删除
	str.erase(1, 3);
	cout << "str = " << str << endl;
	
}

/*string子串

功能描述：从字符串中获取想要的子串

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

*/

void test_sub() {

	string str = "abcdef";

	string subStr = str.substr(1, 3);//（[0]开始） ， 从第n位起，取m个

	cout<< subStr <<endl;

	//实用操作
	string email = "zhangsan@sina.com";

	//从邮件中 获取 用户名信息

	int pos = email.find("@");  //8
	cout<< pos <<endl;

	string userName = email.substr(0, pos);

	cout << userName << endl;
}

/*vector容器

功能：vector数据结构和数组非常相似 ，也称为单端数组           插入删除操作

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;
}

//vector容器构造
void test_vector_01() 
{
	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(10, 100);   //个数 ， 值
	printVector(v3);

}

/*vector容器赋值操作

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


*/

void test_value_01() {
	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);

}

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

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

resize(int num,elem) //重新指定容器的长度num，若容器变长，则以elem填充新位置
					 //如果容器变短，则末尾超出容器长度的元素被删除


*/

void test_capacity_size_01()
{
	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;	//可赋值空间有多少--容量capacity
		cout << "v1的大小为： " << v1.size() << endl;		//已经赋值所占的空间

	}

	//重新指定大小
	v1.resize(15);//如果比原来长，默认值填充0
	printVector(v1);

	v1.resize(20,16);//可更改填充默认值 ，改成了100
	printVector(v1);

	v1.resize(5);//如果比原来短，其余部分被删除
	printVector(v1);
}

/*vector插入和删除
* 
* 功能描述：对vector容器进行插入和删除操作
所有接口：

push_back(elem);   //尾部插入元素elem
pop_back();			//删除最后一个元素
insert(const_iterator pos,elem);   //迭代器指向位置pos插入count个元素elem
erase(const_iterator start,const_iterator end)  //删除迭代器从start到end之间的元素
clear();	//删除容器中所有元素，清空


*/

void test_insert_delete_01() 
{
	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, 1000);
	printVector(v1);
	
	//删除  参数也是迭代器
	v1.erase(v1.begin());//指定位置删除 ， 删除了第一个
	printVector(v1);

	v1.erase(v1.begin(),v1.end());//等效clear
	printVector(v1);

	v1.clear();
}

/*vector数据存取
* 功能描述：	对vector中的数据的存取操作
 
函数原型：
at(int idx);	//返回索引idx所指的数据
operator[];		//返回索引idx所指的数据
front();		//返回容器中的第一个数据元素
back();			//返回容器中的最后一个数据元素

*/

void test_cunqu() 
{
	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;

}

/*vector容器的互换

//1.基本的使用
 

//2.实际用途

*/

//1.基本的使用
void test____01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout<< "交换前"<<endl;
	printVector(v1);

	vector<int>v2;
	for (int i = 0; i < 10; i++)
	{
		v2.push_back(10 - i);
	}
	printVector(v2);
	cout << "交换后" << endl;
	v1.swap(v2);

	printVector(v1);
	printVector(v2);
}

//2.实际用途  
//巧用swap可以收缩节省空间
void test____02()
{
	vector<int>v;
	for (int i = 0; i < 1e6; i++)
	{
		v.push_back(i);
	}
	cout << "v的容量为：" << v.capacity() << endl;   //会比赋值size 大一些防止溢出
	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) ：容器的交换   ，
							  //匿名对象变成很大的原容量释放，v变成刚刚好为
	cout << "v的容量为：" << v.capacity() << endl;//容量收缩 == size
	cout << "v的大小为" << v.size() << endl;
}

/*vector预留空间

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

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

*/

void test_reserve() 
{
	vector<int>v;

	int num = 0;//统计开辟的次数
	int* p = NULL;
	for (int i = 0; i < 1e6; i++)
	{
		v.push_back(i);
	}
	if (p != &v[0])//第一次让p指向v首地址，v空间不够重新开辟时，指针指向的原来的地址 != 现在的地址，指针重新指向现在地址
	{
		p = &v[0];
		num++;		//1e6分配了多少次内存   ，内存不够时重新找空间开辟
	}

}

/*deque容器
* 双端数组 ，可以对头端进行插入删除操作

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




deque内部有个中控器，去记录每个缓冲区地址（未使用的内存地址）    ，使deque看起来是连续的
*/

void printDeque(const deque<int>&d)//防止修改
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)    //要写成 只读迭代器const_iterator
	{
		//*it = 100;   容器中的数据不可以修改了   const     *it 变成不可修改的左值
		cout<< *it<<" ";
	}
	cout << endl;
}
/*
deque(T);		deqT			//默认构造 形式
deque(beg,end);					//构造函数将[beg,end)区间中的元素拷贝给函数本身
deque(n,elem);					//构造函数将n个elem拷贝给本身
deque(const deque &deq);		//拷贝构造函数

*/
void testdeque__01()
{
	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);

}

/*deque赋值操作

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

*/

void testdeque_value_01()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);

	}
	printDeque(d1);

	//operator=
	deque<int>d2;
	d2 = d1;
	printDeque(d2);

	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);

	deque<int>d4;
	d4.assign(10,100);
	printDeque(d4);
}


/*deque大小操作		 //deque容器没有容量的概念!

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

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

*/

//deque<int>    大小操作
void testdeque_capacity_01()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);

	}
	printDeque(d1);

	if (d1.empty())
	{
		cout<< "d1为空"<<endl;
	}
	else 
	{
		cout << "d1不为空" << endl;
		cout << "d1的大小为" << d1.size()<< endl;
		//deque容器没有容量的概念
	}

	//重新指定大小
	//d1.resize(15)
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(5);
	printDeque(d1);



}

/*deque插入删除


头部插入删除
push_front()
pop_front()

尾部插入删除
push_back()
pop_back()

*/

void test_insert__delete_01() 
{
	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(), 1000);
	printDeque(d1);//1000 200 100 10 20

	d1.insert(d1.begin(), 2, 10000);
	printDeque(d1);//10000 10000 1000 200 100 10 20

	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);	//1 2 3 10000 10000 1000 200 100 10 20

	
	deque<int>d3;
	d3.push_back(10);
	d3.push_back(20);
	d3.push_front(100);
	d3.push_front(200);

	//删除
	d3.erase(d3.begin());
	printDeque(d3);

	d3.erase(d3.begin(),d3.end());
	d3.clear();
	printDeque(d3);

}


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

*/
void test_exist_01()
{
	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);

	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;
}

/*deque排序

//*要包含头文件algorithm 
sort(iterator beg,iterator end)  //对beg和end区间内元素进行排序  默认升序从小到大

*/

void test_deque_sort_01()
{
	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);

	//排序前   
	cout<< "排序前"<<endl;
	printDeque(d); //300 200 100 10 20 30

	sort(d.begin(),d.end()); //默认升序
	//排序后
	cout << "排序后" << endl;
	printDeque(d);
}

/*评委打分案例

5名选手，ABCDE ，10个评委分别对每一名选手打分，去除一个最高分，一个最低分，取平均分

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



*/

class Person_1 
{
public:
	Person_1(string name,int score)
	{
		this->m_Name = name;	
		this->m_Score = score; 
	}

	string m_Name;	//姓名
	int m_Score;	//平均分
};

void createPerson(vector<Person_1 > &v)  //*Person型容器存选手类
{	
	//创建选手
	string nameSeed = "ABCDE";
	for (int i = 0; i < 5; i++)
	{
		string name = "选手";
		name += nameSeed[i];//或.appand

		int score = 0;

		Person_1  p(name, score);

		//将创建的person对象放入容器中
		v.push_back(p);
	}

}

//打分
void setScore(vector<Person_1 >& v)
{
	for (vector<Person_1 >::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_front();//deque有头部操作  ，vector没有
		d.pop_back();

		//取平均分
		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_1>& v)
{
	for (vector<Person_1>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名：" << it->m_Name << "  平均分 ： " << it ->m_Score << endl;
	}
}

void test_player_score()
{
	//随机数种子   要包含ctime头文件
	srand((unsigned int)time(NULL));

	//1.创建五名选手，放到vector容器中
	vector<Person_1 >v;//存放选手容器
	createPerson(v); 

	//测试
	/*
	for (vector<Person_1 >::iterator it = v.begin(); it != v.end(); it++)
	{
		cout<< "姓名"<<(*it).m_Name <<"  分数" << (*it).m_Score <<endl;
	}
	*/
	
	//2.给5名选手打分
	setScore(v);       //my类名，函数名一致性
	

	//3.获取平均分
	showScore(v);     

}

int main() {
	//cout<< <<endl;
	test_player_score();

	return 0;
}