Cpp-Containers | Coding Blog

cpp

发布日期: 2023-12-11

更新日期: 2023-12-27

文章字数: 11.9k

阅读时长: 56 分

阅读次数:

官方文档

cpp reference

笔记

关于类

空类的字节数是1;
一个类中,只有非静态成员变量才属于这个类的对象
静态成员函数和非静态成员函数以及静态成员变量均不属于这个对象
自定义数据类型存在内存对齐操作
在成员函数后面加const,修饰的是this指向,让指针指向的值也不可以修改
如果在成员属性前面加上mutable,可以在常函数,常对象下修改

mutable int a;

常对象只能调用常函数（因为非常函数是可以修改属性的,常对象不允许修改属性）

class Person
{
public:
	//如果利用成员函数重载左移运算符
	//明显不能利用成员函数重载,只能用全局函数重载
	//void operator<<(cout)//p<<cout
	//{

	//}
	int m_a;
	int m_b;
};
ostream& operator<<(ostream& cout, Person& p)
{
	cout << "m_a= " << p.m_a << "m_b" << p.m_b;
	return cout;
}
//cout<<p1<<endl;
//返回cout是为了cout<<p1后面的<<可以继续使用;
//cout只能有一个
//所以cout在传入和返回的时候只能采用引用的fan

类私有成员可以被类成员函数访问,不区分成员在哪个实例里
类型转换后指针的指向不变(运行时类型不变),但是编译的时候会变成另一个类型(编译时类型)
相当于只是用了另一个角度来看待这个指针

也就是说

如果person是父类指针当他指向子类对象还是保存的子类对象的地址

但是因为指针类型是父类所以只能访问父类成员

相当于限制访问,只能访问继承的东西,因为有继承关系子类对象一定有父类成员

所以可以用父类指针指向子类对象但是不能用子类指针指向父类对象

父类并不包含子类,所以子类指针指向父类对象会引起编译器的错误认识，容易调用子类独有的成员

当发生强制转换指向子类对象的父类指针强制转换成子类指针就只是改变了看待指针的角度,指针本身没变。

而此时指针可以访问子类的成员,不管怎么转换,地址的内容不变

成员对象初始化，先客人再自己，析构先自己再客人

常量，引用，对象成员的初始化要在成员初始化表中进行，不可以直接=赋值，与位置无关，都是先客人再自己

析构都是先自己再客人

初始化列表无顺序

列表中的成员初始化器的顺序是不相关的：初始化的实际顺序如下:

如果构造函数是最终派生类的，那么按基类声明的深度优先、从左到右的遍历中的出现顺序（从左到右指的是基说明符列表中所呈现的），初始化各个虚基类

然后，以在此类的基类说明符列表中出现的从左到右顺序，初始化各个直接基类

然后，以类定义中的声明顺序，初始化各个非静态成员。

最后，执行构造函数体（注意：如果初始化的顺序是由不同构造函数中的成员初始化器列表中的出现所控制，那么析构函数就无法确保销毁顺序是构造顺序的逆序了–>

Arraytype b[4]={Arraytype(1,2),Arraytype(1,2),Arraytype(1,2),Arraytype(1,2)};数组元素初始化
Arraytype b[4];//缺省构造函数
Arraytype b[4]={1,2,3,4};//调用一个参数构造函数

文件

读文件并不会创建文件
写文件会创建文件

也就是说使用ofs.open之后,ofs.is_open就会失效,判断文件是否存在用ifs

++运算符重载

class Myint
{
	friend ostream& operator<<(ostream& cout, Myint a);
public:
	Myint():a(0)
	{

	}
	//前置
	//返回引用是为了一直对一个数据进行操作,比如++(++a)
	Myint& operator++()
	{
		a++;
		return *this;
	}
	Myint operator++(int)//int代表占位参数,可以区分前置和后置
		//不能返回引用
	{
		Myint temp=*this;
		++(this->a);
		return temp;
		//先 记录当时结果
		//后递增
		//最后将记录结果返回
	}
private:
	int a;
};
ostream& operator<<(ostream& cout, Myint a)//返回临时变量,不能取引用
{
	cout << a.a;
	return cout;
}
void test01()
{
	Myint a;
	cout << a++ << endl;
	cout << a << endl;
}

浅拷贝和深拷贝

若类中有用new申请的堆区内存,采用浅拷贝时只会拷贝地址,不会重新申请内存,导致拷贝出来的内容和原来的内容指向同一个地址

深拷贝则是手写拷贝构造函数,采用new再次申请内存

默认给出的拷贝构造函数为浅拷贝

浅拷贝带来的问题就是堆区的内存重复释放

易错

如果使用等号初始化，并不会调用=的重载版本，而是调用拷贝构造函数

如果存在堆区内存

没有写拷贝构造函数，只写了=赋值的重载，会产生浅拷贝与深拷贝问题

#include <iostream>
using namespace std;
class person
{
public:
    person()
    {
        m_age = NULL;
    }
    person(int age)
    {
        m_age = new int(age);
    }
    /*person(const person& p)
    {
        m_age = new int;
        *m_age = *p.m_age;
    }*/
    person &operator=(person &p)
    {
        if (m_age != NULL)
        {
            delete m_age;
            m_age = NULL;
        }
        this->m_age = new int(11);
        return *this;
    }
    ~person()
    {
        if (m_age != NULL)
        {
            delete m_age;
            m_age = NULL;
        }
    }
    int *m_age;
};
int main()
{
    person p1(10);
    // person p2 = p1;   此句不会调用重载的等号，而是调用拷贝构造函数，因为对象没有实例化，相当于p2(p1),产生浅拷贝问题
    person p2;
    p2=p1;//或者重写拷贝构造函数
    cout << *p2.m_age << endl;
    cout << p2.m_age << endl;
    cout << p1.m_age << endl;
    system("pause");
    return 0;
}

该例中只写了等号重载，没有写拷贝构造函数

如果有

person p1(10);

person p2 = p1;

第二句等价于 person p2(p1);不会调用赋值运算重载，而是调用系统默认的拷贝构造，产生浅拷贝问题

vector

基本概念:

容器:vector;

vector数据结构和数组非常相似,也称为单端数组,可以动态扩展

算法:for_each;

class Person
{
public:
	Person(string name, int age) :m_Name(name), m_age(age)
	{

	}
	string m_Name;
	int m_age;
};
void print(Person s)
{
	cout << s.m_Name << " " << s.m_age << endl;
}
for_each(v.begin(), v.end(), print);//只需要函数名

迭代器:vector::iterator;

类似动态数组

动态分配内存，并不是原有空间下分配，而是找一个新空间，将原有数据拷贝到新空间下，然后释放掉原有空间

容器嵌套容器:

//容器嵌套容器
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);
	v2.push_back(i + 2);
	v3.push_back(i + 3);
	v4.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++)
{
	for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
	{
		cout << *vit;
	}
	cout << endl;
}

构造函数:

vector v;//默认构造函数

vector<int>v1;//默认构造函数

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

int a[10];
vector<int>v2(a, a+10);//左闭右开的区间构造 可以放迭代器也可以放指针 会发生隐式转换

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

vector<int>v3(10, 100);//十个一百初始化

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

vector<int>v4(v3);//拷贝构造函数

赋值操作:

vector& operator=(const vector &vec);//重载等号运算符

vector<int>v1;
for (int i = 0; i < 10; i++)
{
	v1.push_back(i);
}
vector<int>v2;
v2 = v1;

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

vector<int>v3;
v3.assign(v1.begin(), v1.end());

assign(n,elem);//将n个elem拷贝复制给本身

vector<int>v4;
v4.assign(10, 100);

容量和大小:

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

capacity();//容器的容量

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

vector<int>v1;
for (int i = 0; i < 10; i++)
{
	v1.push_back(i);
}
if (v1.empty())//为真代表容器为空
{
	cout << "v1为空" << endl;
}
else
{
	cout << "v1不为空" << endl;
	cout << "v1的容量" << v1.capacity() << endl;
	cout << "v1的元素个数" << v1.size() << endl;//容量大于大小
}

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

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

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

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

v1.resize(15);
for_each(v1.begin(), v1.end(), print);
cout << endl;
v1.resize(25, 10);
for_each(v1.begin(), v1.end(), print);
cout << endl;
v1.resize(10);
for_each(v1.begin(), v1.end(), print);//大了添加默认值，小了删除尾部多余的

插入和删除:

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

vector<int>v1;
for (int i = 0; i < 10; i++)
{
	v1.push_back(i);
}

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

void print(int a)
{
	cout << a << " ";
}
v1.pop_back();
for_each(v1.begin(), v1.end(), print);
cout << endl;

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

v1.insert(v1.begin()+1, 100);
for_each(v1.begin(), v1.end(), print);
cout << endl;

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

v1.insert(v1.begin(), 2, 1000);
for_each(v1.begin(), v1.end(), print);
cout << endl;

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

v1.erase(v1.begin());
for_each(v1.begin(), v1.end(), print);
cout << endl;

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

v1.erase(v1.begin(), v1.begin() + 2);//左闭右开
for_each(v1.begin(), v1.end(), print);
cout << endl;

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

v1.clear();
for_each(v1.begin(), v1.end(), print);
cout << endl;

数据存取:

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

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

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

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

void print(int a)
{
	cout << a << " ";
}
vector<int>v1;
for (int i = 0; i < 10; i++)
{
	v1.push_back(i);
}
   for_each(v1.begin(), v1.end(), print);
   cout << endl;
   cout << v1.at(1);
   cout << endl;
   cout << v1[1];
   cout << endl;
   for_each(v1.begin(), v1.end(), print);
   cout << endl;
   cout << "第一个元素为: " << v1.front() << endl;
   cout << "最后一个元素为: " << v1.back() << endl;

互换容器:

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

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;
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)匿名对象
//vector<int>x();调用拷贝构造函数，x不写就是匿名，拷贝一个v
//此时会按照v的大小进行构造
//所以x的大小和容量为3
//x和v进行互换；
//匿名对象结束自动释放,调用析构函数
cout << "v的容量为: " << v.capacity() << endl;
cout << "v的大小为: " << v.size() << endl;

预留空间:

减少vector在动态扩展容量时的扩展次数

只改变容量不申请内存

reserve()函数预分配出的空间没有被初始化,不可访问

vector<int>v1;
//利用reserve预留空间
v1.reserve(100000);
int num = 0;//统计开辟的次数
int* p = NULL;
for (int i = 0; i < 100000; i++)
{
	v1.push_back(i);
	if (p != &v1[0])
	{
		p = &v1[0];
		num++;
	}
}
cout << "v1开辟的次数: " << num << endl;

string

基本概念

本质:

string是C++风格的字符串,而string本质上是一个类

string和char*的区别:

char*是一个指针

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

特点:

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

例如:查找find,拷贝copy,删除delete,替换replace,插入insert

string管理char*所分配的内存,不用担心复制越界和取值越界,由内部进行负责

构造函数:

string();//创建一个空字符串例如:string str;

string(const char*s);//使用字符串s初始化;

string(const string&str);//使用一个string对象初始化另一个string对象;

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

string s1;//默认构造
string s2("aaa");//使用字符串初始化
const char* str = "aaa";
string s3(str);
string s4(s3);//拷贝构造
string s5(10, 'a');//十个a
cout << s5 << endl;

赋值操作:

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赋给当前字符串

string str1;
str1 = "hello world";
cout << str1 << endl;
string str2;
str2 = str1;
cout << str2 << endl;
string str3;
str3 = 'a';
cout << str3 << endl;
string str4;
str4.assign("hello C++");
cout << str4 << endl;
string str5;
str5.assign("hello C++", 5);//前几个字符去赋值
cout << str5 << endl;
string str6;
str6.assign(str5);
cout << str6 << endl;
string str7;
str7.assign(10, 'w');
cout << str7 << endl;

字符串拼接:

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个字符连接到字符串结尾

//字符串拼接
string str1="我";
str1 += "爱玩游戏";
cout << str1 << endl;
str1 += ';';
cout << str1 << endl;
string str2="LOL DNF";
str1 += str2;
cout << str1 << endl;
string str3="I";
str3.append("Love");
cout << str3 << endl;
str3.append("game abcde", 4);
cout << str3 << endl;、

查找和替换:

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

未找到返回 string::npos;

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;//查找s最后一次出现位置,从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

string str1="abcdefgde";
int pos=str1.find("de");
if (pos == string::npos)
{
	cout << "未找到字符串" <<pos<< endl;
}
else
{
	cout << "找到字符串 pos=" << pos << endl;
}
//rfind和find的区别
//rfind是从右往左查找 find从左往右查找
//find第一次出现的位置
//find最后一次出现的位置
pos=str1.rfind("de");
cout << "pos=" << pos << endl;

string str1 = "abcdefg";
str1.replace(1, 3, "1111");
//把bcd换成1111
cout << str1 << endl;

字符串比较:

=返回 0 >返回1 <返回-1

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

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

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

字符存取:

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

char& at(int n);//通过at方式获取字符串,会检查越界

string str = "hello";
cout << str << endl;
//1.通过[]
for (int i = 0; i < str.length(); i++)
{
	cout << str[i];
}
cout << endl;
//2.通过at
for (int i = 0; i < str.length(); i++)
{
	cout << str.at(i) << " "; //会检查下标
}
cout << endl;

插入和删除:

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

//字符串插入和删除
string str = "hello";
str.insert(1, "111");
cout << str << endl;
//删除
str.erase(1, 3);//不填第二个参数就是从pos开始删完,包括pos
cout << str << endl;

子串获取:

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

string str = "abcdef";
string substr = str.substr(1, 3);
cout << substr << endl;

string emaill = "zhangshan@sina.com";
string substr = emaill.substr(0, emaill.find('@'));//能刚好截到@前面,不包括@
cout << substr << endl;

set:

简介:

所有元素都会在插入时自动被排序

自动排序!

本质:

set/multiset属于关联式容器,底层结构是用二叉树实现

set和multiset区别:

set不允许容器中有重复的元素

multiset允许容器中有重复的元素

包含set头文件就都可以用了

构造函数:

set st;//默认构造函数

set(const set &st);//拷贝构造函数

赋值:

set& operator=(const set &st);//重载等号操作符

void print(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
void test01()
{
	set<int>s1;
	//插入数据只有insert方式
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(30);
	print(s1);
	//set容器特点:所有元素在插入时候自动被排序
	//set容器不允许插入重复值

	//拷贝构造
	set<int>s2(s1);
	print(s2);

	//赋值操作
	set<int>s3;
	s3 = s2;
	print(s3);
}

大小和交换:

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

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

swap(st);//交换两个set容器

不允许重新指定大小

void print(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	set<int>s1;
	//插入数据
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	print(s1);
	//判断是否为空
	if (s1.empty())
	{
		cout << "s1为空" << endl;
	}
	else
	{
		cout << "s1不为空" << endl;
		cout << "s1的大小为:" << s1.size() << endl;
	}
	set<int>s2;
	s2.insert(100);
	s2.insert(300);
	s2.insert(200);
	cout << "s1  ";
	print(s1);
	cout << "s2  ";
	print(s2);
	s1.swap(s2);
	cout << "s1  ";
	print(s1);
	cout << "s2  ";
	print(s2);
}

插入和删除:

insert(elem);//在容器中插入元素

clear();//清除所有元素

erase(pos);//删除pos迭代器所指的元素,返回下一个元素的迭代器

erase(elem);//删除容器中值为elem的元素

void print(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	set<int>s;
	//插入
	s.insert(20);
	s.insert(10);
	s.insert(30);
	s.insert(40);
	//遍历
	print(s);
	//删除
	set<int>::iterator it = s.begin();
	it++;
	s.erase(it);
	print(s);
	//重载版本
	s.erase(30);
	print(s);
	//清空
	s.clear();
	//s.erase(s.begin(), s.end());
}

查找和统计:

find(key);//查找key是否存在,若存在,返回该键的元素的迭代器;若不存在,返回set.end();

count(key);//统计key的元素个数

void print(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void print(const multiset<int>& s)
{
	for (multiset<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	set<int>s;
	s.insert(10);
	s.insert(30);
	s.insert(20);
	s.insert(50);
	print(s);
	multiset<int>s1;
	s1.insert(30);
	s1.insert(40);
	s1.insert(20);
	s1.insert(30);
	print(s1);
	set<int>::iterator it;
	//查找,返回值是迭代器
	it = s.find(60);
	if (it != s.end())
	{
		cout << "找到元素" << *it << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}
	//统计三十的个数
	int num = s.count(10);
	int num1 = s1.count(30);
	cout << num << endl;
	cout << num1 << endl;
}

set和multiset的区别:

set不可以插入重复数据,而multiset可以

set插入数据的同时会返回插入结果,表示插入是否成功

multiset不会检测数据,因此可以插入重复数据

void print(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void print(const multiset<int>& s)
{
	for (multiset<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	set<int>s1;
	multiset<int>s2;
	//pair 返回值
	//s1.insert(20);
	pair<set<int>::iterator,bool> ret=s1.insert(20);
	if (ret.second)
	{
		cout << "插入成功!" << endl;
	}
	else
	{
		cout << "插入失败" << endl;
	}
	s1.insert(30);
	s1.insert(10);
	s1.insert(40);
	s2.insert(20);
	s2.insert(20);
	//multiset允许插入重复值
	//返回迭代器
	s2.insert(40);
	s2.insert(30);
	print(s1);
	print(s2);
}

内置类型指定排序规则:

set容器默认排序规则为从小到大

利用仿函数,可以改变排序规则

class mycmp
{
public:
	//仿函数
	bool operator()(const int v1, const int v2) const
	{
		return v1 > v2;
	}
};
void print(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void print(const set<int,mycmp>& s)
{
	for (set<int,mycmp>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	set<int>s1;
	//必须要在插之前
	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(50);
	s1.insert(30);
	print(s1);
	//指定排序规则为从大到小
	set<int,mycmp>s2;
	//必须要在插之前
	s2.insert(10);
	s2.insert(40);
	s2.insert(20);
	s2.insert(50);
	s2.insert(30);
	print(s2);
}

自定义类型指定排序规则:

class Person
{
public:
	Person(string name, int age) :m_name(name), m_age(age)
	{

	}
	string m_name;
	int m_age;
};
class cmp
{
public:
	bool operator()(const Person& p1, const Person& p2) const{return p1.m_age > p2.m_age;}
};
void test()
{
	//自定义数据类型指定排序规则
	set<Person,cmp>s;
	//创建person对象
	Person p1("刘备", 24);
	Person p2("关羽", 28);
	Person p3("张飞", 25);
	Person p4("赵云", 21);
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);
	for (set<Person,cmp>::const_iterator it = s.begin(); it != s.end(); it++)
	{
		cout << (*it).m_name << (*it).m_age << endl;
	}

}

map

map中所有元素都是pair

pair中第一个元素为key(键值),起到索引作用,第二个元素为value(实值)

所有元素都会根据元素的键值自动排序

map/multimap属于关联式容器,底层结构是用二叉树实现

可以根据key值快速找到value值

map和multimap的区别:

map不允许容器中有重复key值元素

multimap允许容器中有重复key值元素

构造与赋值:

map<T1,T2>mp;//map默认构造函数

map(const map &mp);//拷贝构造函数

map& operator=(const map &mp);//重载等号操作符

void print(const map<int, int>& m)
{
	for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
	{
		cout << (*it).first << " " << (*it).second << endl;
	}
}
void test01()
{
	map<int, int>m1;
	//按照key自动排序
	m1.insert(pair<int, int>(1, 10));
	m1.insert(pair<int, int>(3, 10));
	m1.insert(pair<int, int>(2, 10));
	m1.insert(pair<int, int>(4, 10));
	print(m1);
	map<int, int>m2(m1);
	print(m2);
	//赋值
	map<int, int>m3 = m2;
	print(m3);
}

大小和交换:

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

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

swap(st);//交换两个集合容器

void print(const map<int, int>& m)
{
	for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
	{
		cout << (*it).first << " " << (*it).second << endl;
	}
}
void test01()
{
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 10));
	m.insert(pair<int, int>(5, 10));
	m.insert(pair<int, int>(6, 10));
	if (m.empty())
	{
		cout << "m为空" << endl;
	}
	else
	{
		cout << "m不为空" << endl;
		cout << "m的大小" << m.size() << endl;
	}
}
void test02()
{
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 10));
	m.insert(pair<int, int>(5, 10));
	m.insert(pair<int, int>(6, 10));

	map<int, int>m2;
	m2.insert(pair<int, int>(20, 10));
	m2.insert(pair<int, int>(21, 10));
	m2.insert(pair<int, int>(50, 10));
	m2.insert(pair<int, int>(30, 10));
	m.swap(m2);
	print(m);
	print(m2);
}

插入和删除:

insert(elem);//在容器中插入元素

[]的重载;

clear();//清除所有元素

erase(pos);//删除pos迭代器所指的元素,返回下一个元素的迭代器

erase(beg,end);//删除区间[beg,end)的所有元素,返回下一个元素的迭代器

erase(key);//删除容器中值为key的元素

//第一种
map<int, int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 10));
m.insert(pair<int, int>(5, 10));
m.insert(pair<int, int>(6, 10));
//第二种
m.insert(make_pair(2, 20));//不用写模板参数
//第三种
m.insert(map<int, int>::value_type(3, 30));
//第四种
m[4] = 40;//不建议使用
print(m);
//cout << m[7] << endl;//会自动创建一个,key为7,value为0的数
//主要用于通过key访问value
m.erase(m.begin());
//删除
print(m);
m.erase(m.begin(), m.end());//区间删除
m.clear();//清空

查找和统计:

find(key);//查找key是否存在,若存在,返回该键的元素的迭代器,若不存在,返回map.end();

count(key);//统计key的元素个数

map<int, int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 10));
m.insert(pair<int, int>(5, 10));
m.insert(pair<int, int>(6, 10));

map<int, int>m2;
m2.insert(pair<int, int>(20, 10));
m2.insert(pair<int, int>(21, 10));
m2.insert(pair<int, int>(50, 10));
m2.insert(pair<int, int>(30, 10));
m.swap(m2);
print(m);
print(m2);
cout << (*m.find(20)).first << " " << (*m.find(20)).second << endl;
cout << m.count(20);

排序:

利用仿函数

class cmp
{
public:
	bool operator()(int v1, int v2)const
	{
		return v1 > v2;
	}
};
void print(const map<int, int,cmp>& m)
{
	for (map<int, int,cmp>::const_iterator it = m.begin(); it != m.end(); it++)
	{
		cout << (*it).first << " " << (*it).second << endl;
	}
}
void test01()
{
	//第一种
	map<int, int,cmp>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 10));
	m.insert(pair<int, int>(5, 10));
	m.insert(pair<int, int>(6, 10));
	//第二种
	m.insert(make_pair(2, 20));//不用写模板参数
	//第三种
	m.insert(map<int, int>::value_type(3, 30));
	//第四种
	//m[4] = 40;//不建议使用
	print(m);
	//cout << m[7] << endl;//会自动创建一个,key为7,value为0的数
	//主要用于通过key访问value
	m.erase(m.begin());
	//删除
	//print(m);
	//m.erase(m.begin(), m.end());//区间删除
	//m.clear();//清空
}

pair

成对出现的数据,利用对组可以返回两个数据

不用包含头文件

两种创建方式

pair<type,type>p(value1,value2);

pair<type,type>p=make_pair(value1,value2);

pair<type,type>p=p{value1,value2};//cpp17

void test01()
{
	//第一种方式
	pair<string, int>p("Tom", 20);
	cout << "姓名: " << p.first << "  年龄: " << p.second << endl;
	//第二种方式
	pair<string, int>p1 = make_pair("Jerry", 30);
	cout << "姓名: " << p1.first << "  年龄: " << p1.second << endl;
}

queue

queue容器是一种先进先出的数据结构,它有两个出口

常用接口:

构造函数:

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

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

赋值操作:

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

数据存取:

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

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

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

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

大小操作:

empty();//判断队列是否为空

size();//返回队列的大小

class Person
{
public:
	Person(string name, int age) :m_name(name),m_age(age)
	{

	}
	string m_name;
	int m_age;
};
void test01()
{
	//queue是一种先进先出的数据结构,有两个出口
	//queue不允许有遍历行为
	queue<Person>q,q1;
	//入队push 出队pop
	//队头front 队尾back
	//只能看到队头队尾
	//empty size
	q.push(Person("唐僧",30));
	q.push(Person("孙悟空",1000));
	q.push(Person("猪八戒",900));
	q.push(Person("沙僧",800));
	q1 = q;
	cout << "q1的大小: " << q1.size() << endl;
	cout << "q1的队尾: " << q1.back().m_name << " " << q1.back().m_age << endl;
	cout << "q1的队头: " << q1.front().m_name << " " << q1.front().m_age << endl;
	//出队
	q1.pop();
	cout << "q1的队头: " << q1.front().m_name << " " << q1.front().m_age << endl;
	cout << "q1的大小: " << q1.size() << endl;
}

priority_queue

priority_queue：优先队列，数据预设由大到小排序，即优先权高的数据会先被取出。
定义：
- priority_queuepq;
把元素x 加进priority_queue：
- pq.push(x)；
读取优先权最高的值：
- x = pq.top(）;
- pq.pop(); // 读取后删除
判断是否为空的priority_queue：
- pq.empty() 返回true代表为空
- pq.size() 返回元素个数
如需改变priority_queue的优先权定义：
- priority_queue pq; 预设由大排到小
- priority_queue<T, vector, greater > pq; 改成由小排到大
- priority_queue<T, vector , cmp > pq; 自行定义cmp 排序
自行定义cmp，使用struct：
- 重载运算符() 即仿函数
- 注意：因为优先判定为**!cmp，所以「由大排到小」需「反向**」定义实现「最小值优先」。反之亦然。

class Compare{
public:
    bool operator()(const Type a,const Type b) const{
        //自定义排序规则
    }
};

stack

stack容器是一种先进后出的数据结构,他只有一个出口

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

常用接口:

构造函数:

stackstk;//stack采用模板类实现,stack对象的默认构造形式

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

赋值操作:

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

数据存取:

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

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

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

大小操作:

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

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

//栈不允许有遍历行为
//栈可以判断是否为空 empty
//栈可以返回元素个数 size 是在入栈的时候统计的
//构造只有默认构造和拷贝构造
void test01()
{
	stack<int> s;
	//特点：先进后出的数据结构
	//入栈操作
	s.push(10);
	s.push(20);
	cout << "s的大小: " << s.size() << endl;
	//只要栈不为空就，查看栈顶，并且执行出栈操作
	while (!s.empty())
	{
		cout << s.top() << " ";
		s.pop();
	}
	cout << endl;
	cout << "s的大小: " << s.size();
	s.push(10);
	s.push(20);
}

deque

基本概念:

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

deque和vector的区别:

vector对于头部的插入和删除效率低,数据量越大效率越低

deque相对而言,对头部的插入删除速度会比vector快

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

deque内部工作原理:

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

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

赋值操作:

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

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

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

   void print(const deque<int>& d)
   {
       for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
       {
           cout << *it << " ";
       }
       cout << endl;
}
deque<int>d1;
for (int i = 0; i < 10; i++)
{
	d1.push_back(i);
}
print(d1);
//等号赋值
deque<int>d2;
d2 = d1;
print(d2);
//assign赋值
deque<int>d3;
d3.assign(d1.begin(), d1.end());
print(d3);
deque<int>d4;
d4.assign(10, 100);
print(d4);

大小操作:

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

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

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

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

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

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

   void print(const deque<int>& d)
   {
       for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
       {
           cout << *it << " ";
       }
       cout << endl;
   }
deque<int>d1;
for (int i = 0; i < 10; i++)
{
	d1.push_back(i);
}
print(d1);
//deque没有容量,只有元素个数
cout << "deque的大小" << d1.size() << endl;
cout << "deque是否为空" << d1.empty() << endl;
//deque重新指定大小
d1.resize(5);
print(d1);
//第二个参数为如果空间变大填入的数
d1.resize(10, 100);
print(d1);

插入和删除:

void print(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

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

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

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

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

deque<int>d1;
//尾插
d1.push_back(10);
d1.push_back(100);
//头插
d1.push_front(200);
d1.push_front(20);
print(d1);
//尾删
d1.pop_back();
print(d1);
//头删
d1.pop_front();
print(d1);

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

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

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

deque<int>d1,d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);
d1.push_back(10);
d1.push_back(20);
d1.push_front(100);
d1.push_front(200);
print(d1);
//insert插入
d1.insert(d1.begin() + 1, 2000);
print(d1);
d1.insert(d1.begin(), 2, 10000);//两个一万
print(d1);
d1.insert(d1.begin(), d2.begin(), d2.end());//在头部插一个区间
print(d1);

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

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

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

//deque删除
deque<int>d1;
d1.push_back(10);
d1.push_back(20);
d1.push_front(100);
d1.push_front(200);
print(d1);
d1.erase(d1.begin()+1);
print(d1);
d1.erase(d1.begin() + 1, d1.end());//左闭右开区间删除
print(d1);
d1.clear();
if (d1.empty() == true)
{
	cout << "d1为空" << endl;
}

数据存取:

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

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

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

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

void print(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
deque<int>d1;
d1.push_back(10);
d1.push_back(100);
d1.push_back(20);
d1.push_back(30);
d1.push_front(100);
d1.push_front(200);
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;

排序操作:

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

void print(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;
	d1.push_back(100);
	d1.push_back(1000);
	d1.push_back(20);
	print(d1);
	sort(d1.begin(), d1.end());//随机访问迭代器均支持sort排序
	print(d1);
}

list

基本概念:

功能:

将数组进行链式存储

链表:(list)

是一种物理存储单元上非连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成:

链表由一系列结点组成

结点的组成:

一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

构造函数:

listlist;//list采用模板类实现,对象的默认构造形式

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

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

list(const list &lst);//拷贝构造函数

void print(const list<int>& L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	list<int>L1;//默认构造
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	print(L1);
	list<int>L2(L1);//拷贝构造
	print(L2);
	list<int>L3(L1.begin(), L1.end());//区间构造
	print(L3);
	list<int>L4(10, 1000);//n个elem
	print(L4);
}

赋值和交换:

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

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

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

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

void print(const list<int>& L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	print(L1);
	list<int>L2 = L1;//=赋值
	print(L2);
	list<int>L3;
	L3.assign(L2.begin(), L2.end());//区间赋值
	print(L3);
	list<int>L4;
	L4.assign(10, 100);//n个elem
	print(L4);
}
void test02()
{
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	list<int>L2;
	L2.assign(10, 100);
	print(L1);
	print(L2);
	L1.swap(L2);
	print(L1);
	print(L2);
}

容量和大小:

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

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

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

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

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

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

void print(const list<int>& L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	//大小操作
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	print(L1);
	if (L1.empty())
	{
		cout << "L1为空!" << endl;
	}
	else
	{
		cout << "L1不为空!" << endl;
		cout << "L1的元素个数为: " << L1.size() << endl;
	}
	L1.resize(10, 10000);
	print(L1);
	L1.resize(2);
	print(L1);
}

插入和删除:

push_back(elem);//在容器尾部加入一个元素

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

push_from(elem);//在容器开头插入一个元素

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位置的数据,返回下一个数据的位置

remove(elem);//删除容器中所有与elem值匹配的元素

void print(const list<int>& L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	list<int>L;
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	//头插
	L.push_front(100);
	L.push_front(200);
	L.push_front(300);
	print(L);
	//尾删
	L.pop_back();
	print(L);
	//头删
	L.pop_front();
	print(L);
	//insert插入
	list<int>::iterator it = L.begin();
	it++;
	L.insert(it, 1000);
	print(L);
	it = L.begin();
	//erase删除
	L.erase(it++);
	print(L);
	//移除
	L.push_back(10000);
	print(L);
	L.remove(10000);
	print(L);
	//清空
	L.clear();
	print(L);
}

数据存取:

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

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

void test01()
{
	list<int>L;
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	L.push_back(40);
	for (list<int>::iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	cout << "L第一个元素: " << L.front() << endl;
	cout << "L最后一个元素: " << L.back() << endl;
}
//list<int>::iterator it=L.begin();
//it++;it--;支持双向
//it=it+1;//不报错就支持随机访问，在list里面这种写法报错

反转和排序:

reverse();//反转链表

sort();//链表排序

void print(const list<int>& L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
bool cmp(int a1,int a2)
{
	//降序,第一个数 > 第二个数
	return a1 > a2;
}
void test01()
{
	list<int>L1;
	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);
	print(L1);
	//反转后
	L1.reverse();
	print(L1);
	//排序
	//所有不支持随机访问迭代器的容器,不可以用标准算法
	//不支持随机访问迭代器的容器,内部会提供对应的一些算法
	L1.sort();//从小到大
	print(L1);
	L1.sort(cmp);//从大到小 , 用reverse会浪费效率
	print(L1);
}

排序案例:

案例描述:将Person自定义数据类型进行排序,Person中属性有姓名,年龄,身高

排序规则:按照年龄进行升序,如果年龄相同按照身高进行降序

class Person
{
public:
	Person(string name, int age, int height) :m_name(name),m_age(age),m_height(height)
	{

	}
	string m_name;
	int m_age;
	int m_height;
};
void print(const list<Person>& L)
{
	for (list<Person>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << (*it).m_name << " " << (*it).m_age << " " << (*it).m_height << endl;
	}
}
bool cmp(Person p1, Person p2)
{
	if (p1.m_age == p2.m_age)
	{
		return p1.m_height > p2.m_height;
	}
	return p1.m_age < p2.m_age;
}
void test01()
{
	list<Person>L;
	Person p1("刘备", 35, 175);
	Person p2("曹操", 45, 180);
	Person p3("孙权", 40, 170);
	Person p4("赵云", 25, 190);
	Person p5("张飞", 35, 160);
	Person p6("关羽", 35, 200);
	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);
	L.sort(cmp);
	print(L);
}

评委打分

/*
	create by zhangtao 
	date : 2018 3 16
	createPerson( vector<Person>&v )  创建5名选手，参数1：...
*/

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <vector>
#include <string>
#include <deque>
#include <algorithm>
#include <ctime>

/*
有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。
//1. 创建五名选手，放到vector中
//2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
//3. sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分
//4. deque容器遍历一遍，累加分数，累加分数/d.size()
//5. person.score = 平均分
*/


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

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

void createPerson(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);
		v.push_back(p);
	}
}

void setScore(vector<Person>&v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end();it++)
	{
		//有10个评委给每个人打分
		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、存放选手容器
	vector<Person> v; 
	//2、创建五名选手
	createPerson(v);
	//3、打分
	setScore(v);
	//4、显示得分
	showScore(v);


	////测试
	//for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	//{
	//	cout << "姓名： " << it->m_Name << " 分数： " << it->m_Score << endl;
	//}

	system("pause");
	return EXIT_SUCCESS;
}

STL常用算法

概述：

!!!! 类名() 代表匿名对象

算法主要是由头文件 <algorithm> <functional> <numeric>组成

<algorithm>是所有STL头文件中最大的一个,范围涉及到比较,交换,查找,遍历操作,复制,修改等等

<numeric>体积很小,只包括几个在序列上面进行简单数学运算的模板函数

<functional>定义了一些模板类,用以声明函数对象

1.常用遍历算法

for_each //遍历容器

transform //搬运容器到另一个容器中

for_each:

//普通函数
void print01(int val)
{
	cout << val << " ";
}
//仿函数
class print02
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	for_each(v.begin(), v.end(), print01);
	cout << endl;
	for_each(v.begin(), v.end(), print02());
}

transform:

transform(iterator beg1,iterator end1,iterator beg2, func);

//beg1 源容器开始迭代器

//end1 源容器结束迭代器

//beg2 目标容器开始迭代器

//_func 函数或者函数对象

class myprint
{
public:
	void operator()(int v)
	{
		cout << v << " ";
	}
};
class Transform
{
public:
	int operator()(int v)
	{
		return v*2;
	}
};
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	cout << v.size() << endl;
	vector<int>vTarget;//目标容器
	vTarget.resize(v.size());//不能用reserve，reserve只改变容量不申请内存
	transform(v.begin(), v.end(), vTarget.begin(), Transform());
	for_each(vTarget.begin(), vTarget.end(), myprint());
	cout << endl;
}

2.常用查找算法

find //查找元素

find_if //按条件查找元素

adjacent_find //查找相邻重复元素

binary_search //二分查找法

count //统计元素个数

count_if //按条件统计元素个数

find

//常用查找算法
//find
class Person
{
public:
    bool operator==(Person a)
    {
        return (a.age==age)&&(a.name==name);
    }
    Person(string namea,int agea):name(namea),age(agea)
    {

    }
    string name;
    int age;

};
//查找 内置数据类型
void test01()
{
    vector`<int>`v;
    for(int i=0;i<10;i++)
    {
        v.push_back(i);
    }
    //查找容器中是否有5这个元素
    vector`<int>`::iterator it=find(v.begin(),v.end(),5);
    cout<<*it<<endl;
}
//查找 自定义数据类型
void test02()
{
    vector`<Person>`v;
    Person p1("aaa",10);
    v.push_back(p1);
    v.push_back(Person("bbb",20));
    v.push_back(Person("ccc",30));
    v.push_back(Person("ddd",10));
    v.push_back(Person("eee",40));
    vector`<Person>`::iterator it=find(v.begin(),v.end(),p1);
    cout<<(*it).name<<(*it).age<<endl;
}`