C++ 学习笔记9

最新推荐文章于 2024-10-04 12:29:43 发布
最新推荐文章于 2024-10-04 12:29:43 发布
阅读量126 收藏
点赞数
分类专栏： 学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lt405514623/article/details/120328713
版权
本文全面解析了STL标准模板库，从STL诞生背景出发，介绍了六大组件、容器如vector、deque、list等的使用，详细阐述了算法如排序(sort)、查找(find)及迭代器的应用，并通过实际案例展示了函数对象与谓词概念，适合C++开发者进阶学习。
摘要由CSDN通过智能技术生成

目录

1 STL初识

1.1 STL的诞生

在这里插入图片描述

1.2 STL基本概念

在这里插入图片描述

1.3 STL六大组件

在这里插入图片描述

1.4 STL中容器、算法、迭代器

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

1.5 容器算法迭代器初识

在这里插入图片描述

1.5.1 vector存放内置数据类型

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<algorithm>
//vector容器存放内置数据类型

void myPrint(int val)
{
	cout << val << endl;
}
void test01()
{
	//创建了一个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();//起始迭代器  指向迭代器中第一个元素
	vector<int>::iterator itEnd = 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);
}



int main()
{
	
	test01();
	return 0;
}

1.5.2 Vector存放自定义数据类型

#include<iostream>
using namespace std;
#include<vector>
#include<string>

//vector容器中存放自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
	vector<Person>v;

	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	//向容器中添加数据
	v.push_back(p1);
	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;
	}

}
//存放自定义数据类型  指针
void test02()
{
	vector<Person*>v;

	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	//向容器中添加数据
	v.push_back(&p1);
	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;
	}
}

int main()
{
	
	test01();
	return 0;
}

1.5.3 Vector容器嵌套容器

#include<iostream>
using namespace std;
#include<vector>
#include<string>

//容器嵌套容器
void test01()
{
	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++)
	{
		//(*it)----容器vector<int>
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << " ";
		}
		cout << endl;
	}
}

int main()
{
	
	test01();
	return 0;
}

1.5.4 string基本概念

在这里插入图片描述

1.5.5 string构造函数

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<string>

//string的构造函数
//string();                  //创建一个空的字符串  例如：string str;
//string(const char* s);     //使用字符串s初始化
//string(const string& str); //使用一个string对象初始化另一个string对象
//string(int n, char c);     //使用n个字符c初始化

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

int main()
{
	
	test01();
	return 0;
}

在这里插入图片描述

1.5.6 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);    //把字符串s的前n个字符赋给当前字符串
string& assign(const string &s);        //把字符串s赋给当前字符串
string& assign(int n,char c);           //用n个字符c赋给当前字符串
*/

void test01()
{
	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;
}
int main()
{
	
	test01();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.5.7 string字符串拼接

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<string>

//string字符串拼接
/*
string& operator+=(const char* str);            //重载+=操作符
string& operator+=(const char c);               //重载+=操作符
string& operaotr+=(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个字符连接到字符串结尾
*/

void test01()
{
	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 adec", 4);
	cout << "str3 = " << str3 << endl;

	str3.append(str2);
	// i love game:lol dnf
	cout << "str3 = " << str3 << endl;

	str3.append(str2, 0, 3);//只截取lol
	cout << "str3 = " << str3 << endl;

	str3.append(str2, 4, 3);//只截取dnf，参数2  从哪个位置开始截取，参数3 截取字符个数
	cout << "str3 = " << str3 << endl;

}
int main()
{
	
	test01();
	return 0;
}

在这里插入图片描述

1.5.8 string查找和替换

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<string>

//字符串查找和替换

//1、查找

void test01()
{
	string str1 = "abcdefgde";

	int pos=str1.find("de");
	if (pos == -1)
	{
		cout << "未找到字符串" << endl;
	}
	else
	{
		cout << "找到字符串 pos=" << pos << endl;
	}
	//rfind 和find区别
	//rfind从右往左查找   find从左往右查找
	pos = str1.rfind("de");
	cout << "pos=" << pos << endl;
}
//2、替换
void test02()
{
	string str1 = "abcdefg";
	//从1号位置起3个字符 替换为"1111"
	str1.replace(1, 3, "1111");

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


int main()
{
	
	test01();
	test02();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.5.9 string字符串比较

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<string>

//字符串比较

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


int main()
{
	
	test01();
	
	return 0;
}

1.5.10 string字符存取

在这里插入图片描述

//string 字符串存取
void test01()
{
	string str = "hello";
	cout << "str=" << str << endl;

	//1、通过[]访问单个字符
	for (int i = 0; i < str.size(); i++)
	{
		cout << str[i] << " ";
	}
	cout << endl;

	//2、通过at方式访问单个字符
	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;

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

	str.at(1) = 'x';
	//xxllo
	cout << "str=" << str << endl;
}


int main()
{
	
	test01();
	
	return 0;
}

在这里插入图片描述

1.5.11 string插入和删除

在这里插入图片描述

//字符串  插入和删除
void test01()
{
	string str = "hello";

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

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


int main()
{
	
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.5.11 string子串

在这里插入图片描述

/string求子串
void test01()
{
	string str = "abcdef";
	string subStr = str.substr(1, 3);
	cout << "subStr=" << subStr << endl;
}
//实用操作
void test02()
{
	string email = "zhangsan@sina.com";
	//从邮件地址中  获取  用户名信息

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

	string usrName = email.substr(0, pos);
	cout << usrName << endl;
}

int main()
{
	
	test01();
	
	return 0;
}

在这里插入图片描述

1.6 vector容器

1.6.1 vector基本概念

在这里插入图片描述
在这里插入图片描述

1.6.2 vector构造函数

在这里插入图片描述

void printVector(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " " << endl;
	}
}
//vector容器构造
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(10, 100);
	printVector(v3);

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


}

int main()
{
	
	test01();
	
	return 0;
}

1.6.3 vector赋值操作

在这里插入图片描述

void printVector(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
//vector赋值
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();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.6.4 vector容量和大小

在这里插入图片描述

void printVector(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
//vector容器的容量和大小操作
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, 100);//利用重载版本，可以指定默认填充值，参数2
	printVector(v1);//如果重新指定的比原来长了，默认用0填充新的位置

	v1.resize(5);
	printVector(v1);//如果重新指定的比原来短了，超出部分会删除
}

int main()
{
	
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.6.5 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, 1000);
	printVector(v1);

	//删除
	v1.erase(v1.begin());
	printVector(v1);

	//清空
	//v1.erase(v1.begin(), v1.end());
	v1.clear();
	printVector(v1);
}

int main()
{
	
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.6.6 vector数据存取

在这里插入图片描述

//vector容器  数据存取

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();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.6.7 vector互换容器

在这里插入图片描述


//vector容器互换
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);  //匿名对象
	cout << "v的容量为：" << v.capacity() << endl;
	cout << "v的大小为：" << v.size() << endl;
}

int main()
{
	
	test01();
	test02();
	return 0;
}

在这里插入图片描述

1.6.8 vector预留空间

在这里插入图片描述

//vector容器 预留空间

void test01()
{
	vector<int>v;

	//利用reserve预留空间
	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();
	
	return 0;
}

在这里插入图片描述

1.7 deque容器

1.7.1 deque容器基本概念

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

1.7.2 deque构造函数

在这里插入图片描述

//deque 构造函数
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();
	
	return 0;
}

在这里插入图片描述

1.7.3 deque赋值操作

在这里插入图片描述

//deque容器赋值操作
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);

	//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(10, 100);
	printDeque(d4);


}

int main()
{
	
	test01();
	
	return 0;
}

在这里插入图片描述

1.7.4 deque大小操作

在这里插入图片描述

//deque容器大小操作
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);

	if (d1.empty())
	{
		cout << "d1为空" << endl;
	 }
	else
	{
		cout << "d1不为空" << endl;
		cout << "d1的大小为：" << d1.size() << endl;
		//deque容器没有容量概念
	}
	//重新指定大小
	d1.resize(15);
	printDeque(d1);
	d1.resize(15, 1);
	printDeque(d1);
	d1.resize(5);
	printDeque(d1);

}

int main()
{
	
	test01();
	
	return 0;
}

在这里插入图片描述

1.7.5 deque插入和删除

.在这里插入图片描述

//deque容器插入和删除
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;
	//尾插
	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();
	//200 100 10
	printDeque(d1);

	//头删
	d1.pop_front();
	//100 10
	printDeque(d1);
}
void test02()
{
	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);
	//1000 200 100 10 20
	printDeque(d1);

	d1.insert(d1.begin(), 2, 10000);
	//10000 10000 1000 200 100 10 20
	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());
	//1 2 3 10000 10000 1000 200 100 10 20
	printDeque(d1);
}
void test03()
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(100);
	d1.push_front(200);

	//删除
	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);

}

在这里插入图片描述

1.7.6 deque数据存取

在这里插入图片描述

//deque容器数据存取
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;
	
}

在这里插入图片描述

1.7.7 deque排序

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<string>
#include<deque>
#include<algorithm>//标准算法头文件
void printDeque(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
//deque容器排序
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();
	return 0;
}

在这里插入图片描述

1.8 案例-评委打分

在这里插入图片描述
在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<string>
#include<deque>
#include<algorithm>//标准算法头文件
#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);
	return 0;
}

在这里插入图片描述

1.9 stack容器

1.9.1 stack基本概念

在这里插入图片描述
在这里插入图片描述

1.9.2 stack 常用接口

在这里插入图片描述

//栈stack容器
void test01()
{
	//特点：符合先进后出数据结构
	stack<int>s;

	//入栈
	s.push(10);
	s.push(20);
	s.push(30);
	s.push(40);

	cout << "栈的大小：" << s.size() << endl;

	//只要栈不为空，查看栈顶，并且执行出栈操作
	while (!s.empty())
	{
		//查看栈顶元素
		cout << "栈顶元素为：" << s.top() << endl;

		//出栈
		s.pop();
	}
	cout << "栈的大小：" << s.size() << endl;
}




int main()
{
	test01();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.10 queue容器

1.10.1 queue基本概念

在这里插入图片描述
在这里插入图片描述

1.10.2 queue常用接口

在这里插入图片描述

#include<iostream>
using namespace std;
#include<queue>
#include<string>

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
	//创建队列
	queue<Person>q;

	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 900);
	Person p4("沙僧", 800);

	//入队
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	cout << "队列大小为：" << q.size() << endl;
	//判断只要队列不为空，查看队头，查看队尾，出队
	while (!q.empty())
	{
		//查看队头
		cout << "队名元素 ----姓名：" << q.front().m_Name << " 年龄：" << q.front().m_Age << endl;

		//查看队尾
		cout << "队尾元素 ----姓名：" << q.back().m_Name << " 年龄：" << q.back().m_Age << endl;

		//出队
		q.pop();
	}
	cout << "队列大小为：" << q.size() << endl;
}




int main()
{
	test01();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.11 list容器

1.11.1 list基本概念

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.11.2 list构造函数

在这里插入图片描述

include<iostream>
using namespace std;
#include<list>
#include<string>
//list容器构造函数

void printList(const list<int>& L)
{
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	//创建list容器
	list<int>L1;

	//添加数据
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	//遍历容器
	printList(L1);

	//区间方式构造
	list<int>L2(L1.begin(), L1.end());
	printList(L2);

	//拷贝构造
	list<int>L3(L2);
	printList(L3);

	//n个elem
	list<int>L4(10, 1000);
	printList(L4);
}




int main()
{
	test01();
	return 0;
}

在这里插入图片描述

在这里插入图片描述

1.11.3 list赋值和交换

在这里插入图片描述

#include<iostream>
using namespace std;
#include<list>
#include<string>
//list容器赋值和交换

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

	printList(L1);

	list<int>L2;
	L2 = L1;//operator= 赋值
	printList(L2);

	list<int>L3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);

	list<int>L4;
	L4.assign(10, 100);
	printList(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);

	cout << "交换前：" << endl;
	printList(L1);
	printList(L2);

	cout << "交换后：" << endl;
	printList(L1);
	printList(L2);
}
int main()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述

在这里插入图片描述

1.11.4 list大小操作

在这里插入图片描述

#include<iostream>
using namespace std;
#include<list>
#include<string>
//list容器大小操作

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

	printList(L1);

	//判断容器是否为空
	if (L1.empty())
	{
		cout << "L1为空" << endl;
	}
	else
	{
		cout << "L1不为空" << endl;
		cout << "L1的元素个数为：" <<L1.size()<< endl;
	}
	//重新指定大小
	L1.resize(10);
	printList(L1);

	L1.resize(2);
	printList(L1);
	

}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.11.5 list插入和删除

在这里插入图片描述

#include<iostream>
using namespace std;
#include<list>
#include<string>
//list容器插入和删除

void printList(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_back(40);

	//头插
	L.push_front(100);
	L.push_front(200);
	L.push_front(300);
	//300 200 100 10 20 30
	printList(L);

	//尾删
	L.pop_back();
	//300 200 100 10 20 
	printList(L);

	//头删
	L.pop_front();
	//200 100 10 20
	printList(L);

	//insert插入
	list<int>::iterator it = L.begin();
	L.insert(++it, 1000);
	// 200 1000 100 10 20
	printList(L);

	//删除
	it = L.begin();
	L.erase(++it);
	//200 100 10 20
	printList(L);

	//移除
	L.push_back(10000);
	L.push_back(10000);
	L.push_back(10000);
	L.push_back(10000);
	printList(L);
	L.remove(10000);
	printList(L);

	//清空
	L.clear();
	printList(L);



}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.11.6 list数据存取

在这里插入图片描述

#include<iostream>
using namespace std;
#include<list>
#include<string>
//list容器  数据存取

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

	//L1[0] 不可以用[]访问list容器中的元素
	//L1.at(0) 不可以用at方式访问list容器中的元素

	//原因是list本质链表，不是用连续线性空间存储数据，迭代器也不是不支持随机访问的
	cout << "第一个元素为：" << L1.front() << endl;
	cout << "最后一个元素为：" << L1.back() << endl;

	//验证迭代器是不支持随机访问的
	list<int>::iterator it = L1.begin();
	it++;//支持双向
	it--;
	//it=it+1;//不支持随机访问

}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述

1.11.7 list 反转和排序

在这里插入图片描述

#include<iostream>
using namespace std;
#include<list>
#include<string>
//list容器反转和排序

void printList(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(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	cout << "反转前：" << endl;
	printList(L1);
	L1.reverse();
	cout << "反转后：" << endl;
	printList(L1);
}
bool myCompare(int v1, int v2)
{
	return v1 > v2;
}



//排序
void test02()
{
	list<int>L1;
	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	//排序
	cout << "排序前：" << endl;
	printList(L1);

	//所有不支持随机访问迭代器的容器，不可以用标准算法
	//不支持随机访问迭代器的容器，内部会提供对应一些算法
	//sort(L1.begin(),L1.end());

	L1.sort();//默认排序规则  从小到大  升序
	cout << "排序后：" << endl;
	printList(L1);

	L1.sort(myCompare);
	printList(L1);
}

int main()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.11.8 排序案例

在这里插入图片描述

#include<iostream>
using namespace std;
#include<list>
#include<string>
//list容器 排序案例  对于自定义数据类型  做排序

//按照年龄进行升序，如果年龄相同按照身高进行降序

class Person
{
public:
	Person(string name, int age, int height)
	{
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
	}
	string m_Name;//姓名
	int m_Age;//年龄
	int m_Height;//身高
};
//指定排序规则
bool comparePerson(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);

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
	{
		cout << "姓名：" << (*it).m_Name << " 年龄：" << it->m_Age << " 身高：" << it->m_Height << endl;
	}
	//排序
	cout << "-----------------------------" << endl;
	cout << "排序后：" << endl;
	L.sort(comparePerson);//排序
	for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
	{
		cout << "姓名：" << (*it).m_Name << " 年龄：" << it->m_Age << " 身高：" << it->m_Height << endl;
	}

}
int main()
{
	test01();

	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.12 set/multiset容器

1.12.1 set基本概念

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<set>

//set容器构造和赋值
void printSet(set<int>& s)
{
	for (set<int>::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);
	s1.insert(30);

	//遍历容器
	//set容器特点 ：所有元素插入时候自动被排序
	//set容器不允许插入重复值
	printSet(s1);

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

	//赋值
	set<int>s3;
	s3 = s2;
	printSet(s3);
}
int main()
{
	test01();

	return 0;
}

在这里插入图片描述

1.12.2 set大小和交换

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<set>

//set容器 大小和交换


void printSet(set<int>& s)
{
	for (set<int>::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);
	//打印容器
	printSet(s1);

	//判断是否为空
	if (s1.empty())
	{
		cout << "s1为空" << endl;
	}
	else
	{
		cout << "s1不为空" << endl;
		cout << "s1的大小为：" << s1.size() << endl;
	}
}
//交换
void test02()
{
	set<int>s1;

	//插入数据
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	set<int>s2;

	//插入数据
	s2.insert(100);
	s2.insert(300);
	s2.insert(200);
	s2.insert(400);

	cout << "交换前：" << endl;
	printSet(s1);
	printSet(s2);

	cout << "交换后：" << endl;
	s1.swap(s2);
	printSet(s1);
	printSet(s2);
}
int main()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述

1.12.3 set插入和删除

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<set>

//set容器 插入和删除


void printSet(set<int>& s)
{
	for (set<int>::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);
	//遍历
	printSet(s1);

	//删除
	s1.erase(s1.begin());
	printSet(s1);

	//删除重载版本
	s1.erase(30);
	printSet(s1);

	//清空
	//s1.erase(s1.begin(), s1.end());
	s1.clear();
	printSet(s1);

}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述

1.12.4 set查找和统计

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<set>

//set容器 查找和统计


void printSet(set<int>& s)
{
	for (set<int>::iterator it = s.begin(); it != s.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	//查找
	set<int>s1;

	//插入数据
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);

	set<int>::iterator pos = s1.find(30);

	if (pos != s1.end())
	{
		cout << "找到元素：" << *pos << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

}
void test02()
{
	//查找
	set<int>s1;
	//插入数据
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);
	s1.insert(30);
	s1.insert(30);

	//统计30的个数
	int num = s1.count(30);
	//对于set而言  统计结果  要么是0  要么是1
	cout << "num=" << num << endl;
}

int main()
{
	test01();

	test02();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.12.5 set和multiset区别

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<set>

//set容器 和 multiset容器区别


void printSet(set<int>& s)
{
	for (set<int>::iterator it = s.begin(); it != s.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int>s;
	pair<set<int>::iterator, bool> ret = s.insert(10);

	if (ret.second)
	{
		cout << "第一次插入成功" << endl;
	}
	else
	{
		cout << "第一次插入失败" << endl;
	}

	ret = s.insert(10);
	if (ret.second)
	{
		cout << "第一次插入成功" << endl;
	}
	else
	{
		cout << "第一次插入失败" << endl;
	}

	multiset<int>ms;
	//允许插入重复值
	ms.insert(10);
	ms.insert(10);
	ms.insert(10);
	ms.insert(10);
	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl; 
}


int main()
{
	test01();

	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.12.5 pair对组创建

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<set>

//pair对组的创建
void test01()
{
	//第一种方式
	pair<string, int>p("Tom", 20);
	cout << "姓名：" << p.first << "年龄：" << p.second << endl;

	//第二种方式
	pair<string, int>p2 = make_pair("Jerry", 30);
	cout << "姓名：" << p2.first << "年龄：" << p2.second << endl;
}


int main()
{
	test01();

	
	return 0;
}

在这里插入图片描述

1.12.6 set容器排序

#include<iostream>
using namespace std;
#include<string>
#include<set>

//set容器排序
class MyCompare
{
public:
	bool operator()(int v1, int v2)const
	{
		return v1 > v2;
	}
};
void test01()
{
	set<int>s1;
	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(30);
	for(set<int>::iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	//指定排序规则为从大到小
	set<int, MyCompare>s2;

	s2.insert(10);
	s2.insert(40);
	s2.insert(20);
	s2.insert(50);
	s2.insert(30);

	for (set<int, MyCompare>::iterator it = s2.begin(); it!= s2.end(); it++)
	{
		cout << *it << " " ;
	}
	cout << endl;
}


int main()
{
	test01();

	
	return 0;
}

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<set>

//set容器排序 ，存放自定义数据类型

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
class comparePerson
{
public:
	bool operator()(const Person& p1, const Person& p2)const
	{
		//按照年龄 降序
		return p1.m_Age > p2.m_Age;
	}
};




void test01()
{
	//自定义数据类型  都会指定排序规则
	set<Person,comparePerson>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,comparePerson>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << "姓名：" << it->m_Name << "年龄：" << it->m_Age << endl;
	}
}


int main()
{
	test01();

	
	return 0;
}

在这里插入图片描述

1.13 map/multimap容器

1.13.1 map基本概念

在这里插入图片描述

1.13.2 map构造和赋值

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<map>

//map容器  构造和赋值

void printMap( map<int, int>& m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << " key=" << (*it).first << " value=" << it->second << endl;
	}
	cout << endl;
}
void test01()
{
	//创建map容器
	map<int, int>m;

	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(4, 40));
	printMap(m);

	//拷贝构造
	map<int, int>m2(m);
	printMap(m2);

	//赋值
	map<int, int>m3;
	m3 = m2;
	printMap(m3);
}


int main()
{
	test01();

	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.13.3 map大小和交换

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<map>

//map容器  大小和交换

void printMap( map<int, int>& m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << " key=" << (*it).first << " value=" << it->second << endl;
	}
	cout << endl;
}
//大小
void test01()
{

	map<int, int>m;

	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(4, 40));

	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, 20));
	m.insert(pair<int, int>(3, 30));

	map<int, int>m2;
	m2.insert(pair<int, int>(4, 100));
	m2.insert(pair<int, int>(5, 200));
	m2.insert(pair<int, int>(6, 300));

	cout << "交换前：" << endl;
	printMap(m);
	printMap(m2);
	cout << "交换后：" << endl;
	printMap(m);
	printMap(m2);
}


int main()
{
	test01();

	test02();
	return 0;
}

在这里插入图片描述

1.13.4 map插入和删除

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<map>

//map容器  插入和删除

void printMap( map<int, int>& m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << " key=" << (*it).first << " value=" << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int, int>m;
	//插入
	//第一种
	m.insert(pair<int, int>(1, 10));

	//第二种
	m.insert(make_pair(2, 20));

	//第三种
	m.insert(map<int, int>::value_type(3, 30));

	//第四种
	m[4] = 40;

	//[]不建议插入，用途 可以利用key访问到value
	//cout << m[4] << endl;
	printMap(m);

	//删除
	m.erase(m.begin());
	printMap(m);

	m.erase(3);//按照key删除
	printMap(m);

	//清空
	//m.erase(m.begin(), m.end());
	m.clear();
	printMap(m);
}

int main()
{
	test01();


	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.13.5 map查找和统计

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<map>

//map容器  查找和统计

void printMap( map<int, int>& m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << " key=" << (*it).first << " value=" << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	//查找
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	map<int, int>::iterator pos = m.find(3);
	if (pos != m.end())
	{
		cout << "查到了元素key=" << (*pos).first << "value=" << pos->second << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}
	//统计
	//map不允许插入重复key 元素，count统计而言  结果要么是0 要么是1
	//multimap的count统计可能大于1
	int num=m.count(3);
	cout << "num=" << num << endl;
}

int main()
{
	test01();


	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.13.6 map容器排序

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<map>

//map容器  排序
class MyCompare
{
public:
	bool operator()(int v1, int v2)const
	{
		//降序
		return v1 > v2;
	}
};


void test01()
{
	map<int, int,MyCompare>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(5, 50));

	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key=" << it->first << " value=" << it->second << endl;
	}

	
}

int main()
{
	test01();


	return 0;
}

在这里插入图片描述
在这里插入图片描述

1.14 案例

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<map>
#include<ctime>

#define CEHUA 0
#define MEISU 1
#define YANFA 2
class Worker
{
public:
	string m_Name;
	int m_Salary;
};
void createWorker(vector<Worker>& v)
{
	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++)
	{
		Worker worker;
		worker.m_Name = "员工";
		worker.m_Name += nameSeed[i];

		worker.m_Salary = rand() % 10000 + 10000;//10000~19999
		//将员工放入到容器中
		v.push_back(worker);
	}

}
//员工分组
void setGroup(vector<Worker>& v, multimap<int, Worker>& m)
{
	for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++)
	{
		//产生随机部门编号
		int depId = rand() % 3;//0 1 2
		//将员工插入到分组中
		m.insert(make_pair(depId, *it));
	}
}
void showWorkerByGourp(multimap<int,Worker>&m)
{
	//0 A B C 1 D E F  2 F G ..
	cout << "策划部门：" << endl;
	multimap<int,Worker>:: iterator pos=m.find(CEHUA);
	int count = m.count(CEHUA);//统计具体人数
	int index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
	}
	cout << "-------------------------------" << endl;
	cout << "美术部门：" << endl;
	pos = m.find(MEISU);
    count = m.count(MEISU);//统计具体人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
	}
	cout << "-------------------------------" << endl;
	cout << "研发部门：" << endl;
	pos = m.find(YANFA);
	count = m.count(YANFA);//统计具体人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
	}
}
int main()
{
	srand((unsigned int)time(NULL));
	//1、创建员工
	vector<Worker>vWorker;
	createWorker(vWorker);

	//2、员工分组
	multimap<int, Worker>mWorker;
	setGroup(vWorker, mWorker);

	//3、分组显示员工
	showWorkerByGourp(mWorker);
	测试
	//for (vector<Worker>::iterator it = vworker.begin(); it != vworker.end(); it++)
	//{
	//	cout << " 姓名：" << it->m_Name << " 工资：" << it->m_Salary << endl;
	//}

	return 0;
}

在这里插入图片描述

2 STL-函数对象

2.1 函数对象

2.1.1 函数对象概念

在这里插入图片描述

2.1.2 函数对象使用

在这里插入图片描述

#include<iostream>
using namespace std;
#include<string>

//函数对象（仿函数）
class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};
//1、函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
void test01()
{
	MyAdd myadd;
	cout << myadd(10, 10) << endl;
}
//2、函数对象超出普通函数的概念，函数对象可以有自己的状态
class MyPrint
{
public:
	MyPrint()
	{
		this->count = 0;
	}
	void operator()(string test)
	{
		cout << test << endl;
		this->count++;
	}
	int count;//内部自己状态
};
void test02()
{
	MyPrint myPrint;
	myPrint("hello world");
	myPrint("hello world");
	myPrint("hello world");
	myPrint("hello world");

	cout << "myPrint调用次数为：" << myPrint.count << endl;
}
//3、函数对象可以作为参数传递
void doPrint(MyPrint& mp, string test)
{
	mp(test);
}
void test03()
{
	MyPrint myPrint;
	doPrint(myPrint, "Hello c++");
}
int main()
{
	test01();
	test02();
	test03();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

2.2 谓词

2.2.1谓词概念

在这里插入图片描述

2.2.2 一元谓词

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<algorithm>
//仿函数 返回值类型是bool数据类型，称为谓词
//一元谓词
class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//查找容器中 有没有大于5的数字
	//GreaterFive() 匿名函数对象
	vector<int>::iterator it= find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "找到了大于5的数字为：" << *it << endl;
	}
}
int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

2.2.3 二元谓词

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<algorithm>

//二元谓词
class MyCompare
{
public:
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}
};
void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);
	sort(v.begin(), v.end());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it <<" ";
	}
	cout << endl;

	//使用函数对象  改变算法策略 ，变为排序规则为从大到小
	sort(v.begin(), v.end(), MyCompare());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述

2.3 内键函数对象

2.3.1 内键函数对象意义

在这里插入图片描述

2.3.2 算术仿函数

在这里插入图片描述

#include<iostream>
using namespace std;
#include<functional> //内建函数对象头文件


//内键函数对象 算术仿函数

//negate 一元仿函数  取反仿函数

void test01()
{
	negate<int>n;
	cout << n(50) << endl;
}

//plus 二元仿函数 加法
void test02()
{
	plus<int>p;
	cout << p(10, 20) << endl;
}
int main()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述

2.3.3 关系仿函数

在这里插入图片描述

#include<iostream>
using namespace std;
#include<functional> //内建函数对象头文件
#include<vector>
#include<algorithm>
#include<functional>

//内键函数对象 关系仿函数
//大于 greater
class MyCompare
{
public:
	bool operator()(int v1, int v2)
	{
		return v1 > v2;
	}
};
void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(40);
	v.push_back(20);
	v.push_back(50);

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	//降序
	//sort(v.begin(), v.end(), MyCompare());
	//greater<int>() 内建函数对象
	sort(v.begin(), v.end(), greater<int>());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}


int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

3.3.4 逻辑仿函数

在这里插入图片描述

#include<iostream>
using namespace std;
#include<functional> //内建函数对象头文件
#include<vector>
#include<algorithm>
#include<functional>

//内建函数对象_逻辑仿函数
//逻辑非 logical_not
void test01()
{
	vector<bool>v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);

	for (vector<bool>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	//利用逻辑非，将容器v搬运到 容器v2中，并执行取反操作
	vector<bool>v2;
	v2.resize(v.size());
	transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}


int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4 STL-算法

在这里插入图片描述

4.1 常用遍历算法

在这里插入图片描述

4.1.1 for_each

在这里插入图片描述

#include<iostream>
using namespace std;
#include<functional> 
#include<vector>
#include<algorithm>
#include<functional>

//常用遍历算法 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());
	cout << endl;
}


int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.1.2 transform

在这里插入图片描述

#include<iostream>
using namespace std;
#include<functional> 
#include<vector>
#include<algorithm>
#include<functional>

//常用遍历算法 transform

class Transform
{
public:
	int operator()(int v)
	{
		return v;
	}
};
class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	
	vector<int>vTagrget;//目标容器
	vTagrget.resize(v.size());//目标容器  需要提前开辟空间
	transform(v.begin(), v.end(), vTagrget.begin(), Transform());

	for_each(vTagrget.begin(), vTagrget.end(), MyPrint());
	cout << endl;
}


int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.2 常用查找算法

在这里插入图片描述

4.2.1 find

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法
//find

//查找 内置数据类型
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);
	if (it == v.end())
	{
		cout << "没有找到！" << endl;
	}
	else
	{
		cout << "找到：" << *it << endl;
	}
}
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	//重载 == 底层find知道如何对比person数据类型
	bool operator==(const Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	string m_Name;
	int m_Age;
};
//查找 自定义数据类型
void test02()
{
	vector<Person>v;
	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);

	//放入到容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	Person pp("bbb", 20);
	vector<Person>::iterator it = find(v.begin(), v.end(), pp);
	if (it == v.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{
		cout << "找到元素 姓名：" << it->m_Name << " 年龄：" << it->m_Age << endl;
	}
}

int main()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.2.2 find_if

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法 find_if

//1、查找内置数据类型
class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	vector<int>::iterator it= find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{
		cout << "找到大于5的数字为：" << *it << endl;
	}
}
//2、查找自定义数据类型
class Person
{
public:
	Person(string name,int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
class Greater20
{
public:
	bool operator()(Person& p)
	{
		return p.m_Age > 20;
	}
};
void test02()
{
	vector<Person>v;
	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	//找年龄大于20的人
	vector<Person>::iterator it= find_if(v.begin(), v.end(), Greater20());
	if (it == v.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{
		cout << "找到姓名:" << it->m_Name << "年龄" << it->m_Age << endl;
	}
}
int main()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述

4.2.2 adjacent_find

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法 adjacent_find


void test01()
{
	vector<int>v;
	v.push_back(0);
	v.push_back(2);
	v.push_back(0);
	v.push_back(3);
	v.push_back(1);
	v.push_back(4);
	v.push_back(3);
	v.push_back(3);

	vector<int>::iterator pos= adjacent_find(v.begin(), v.end());
	if (pos == v.end())
	{
		cout << "未找到相邻重复元素" << endl;
	}
	else
	{
		cout << "找到相邻重复元素：" << *pos << endl;
	}
}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.2.4 binary_search

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法 binary_search

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//查找容器中是否有9元素
	//注意：容器必须是有序的序列
	bool ret= binary_search(v.begin(), v.end(), 9);

	if (ret)
	{
		cout << "找到了元素" << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
}

int main()
{
	test01();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.2.5 count

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法 count

//1、统计内置数据类型

void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(30);
	v.push_back(40);
	v.push_back(20);
	v.push_back(40);

	int num = count(v.begin(), v.end(), 40);
	cout << "40的元素个数为：" << num << endl;
}
//2、统计自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	bool operator==(const Person& p)
	{
		if (this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	string m_Name;
	int m_Age;

};
void test02()
{
	vector<Person>v;
	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p3("张飞", 35);
	Person p4("赵云", 30);
	Person p5("曹操", 40);
	//将人员插入到容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	Person p("诸葛亮", 35);

	int num=count(v.begin(), v.end(), p);
	cout << "和诸葛亮同岁数的人员个数为：" << num << endl;

}
int main()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.2.6 count_if

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用查找算法 count_if

//1、统计内置数据类型
class Greater20
{
public:
	bool operator()(int val)
	{
		return val > 20;
	}
};
void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(30);
	v.push_back(40);
	v.push_back(20);
	v.push_back(40);

	int num = count_if(v.begin(), v.end(), Greater20());
	cout << "大于20的元素个数为：" << num << endl;
}
//2、统计自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	
	string m_Name;
	int m_Age;
};
class AgeGreater20
{
public:
	bool operator()(const Person& p)
	{
		return p.m_Age > 20;
	}
};
void test02()
{
	vector<Person>v;
	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p3("张飞", 35);
	Person p4("赵云", 30);
	Person p5("曹操", 40);
	//将人员插入到容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	Person p("诸葛亮", 35);

	int num=count_if(v.begin(), v.end(), AgeGreater20());
	cout << "和诸葛亮同岁数的人员个数为：" << num << endl;

}
int main()
{
	test01();
	test02();
	return 0;
}

在这里插入图片描述

4.3 常用排序算法

在这里插入图片描述

4.3.1 sort

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
//常用排序算法 sort
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(30);;
	v.push_back(20);
	v.push_back(50);
	//利用sort进行升序
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;

	//改变为降序
	sort(v.begin(), v.end(), greater<int>());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;

	
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.3.2 random_shuffle

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<ctime>
//常用排序算法 random_shuffle
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	srand((unsigned int)time(NULL));
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//利用洗牌 算法 打乱顺序
	random_shuffle(v.begin(), v.end());

	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述

4.3.3 merge

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
void myPrint(int val)
{
	cout << val << " ";
}
//常用排序算法 merge
void test01()
{
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 1);
	}
	//目标容器
	vector<int>vTarget;
	//提前给目标容器分配空间
	vTarget.resize(v1.size() + v2.size());
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), vTarget.end(), myPrint);
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.3.4 reverse

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);

	cout << "反转前：" << endl;
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
	cout << "反转后：" << endl;
	reverse(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.4 常用拷贝和替换算法

在这里插入图片描述

4.4.1 copy

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 copy
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	vector<int>v2;
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());
	for_each(v2.begin(), v2.end(), myPrint);
	cout << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.4.2 replace

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 replace
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int>v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);
	v.push_back(30);
	v.push_back(40);
	v.push_back(20);
	v.push_back(10);
	v.push_back(20);
	cout << "替换前：" << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	//将20替换 2000
	replace(v.begin(), v.end(), 20, 2000);
	cout << "替换后：" << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.4.3 replace_if

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 replace_if
class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
class Greater30
{
public:
	bool operator()(int val)
	{
		return val >= 30;
	}
};
void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(30);

	cout << "替换前：" << endl;
	for_each(v.begin(), v.end(),MyPrint());
	//将大于等于30 替换为3000
	replace_if(v.begin(), v.end(), Greater30(), 3000);
	cout << "替换后：" << endl;
	for_each(v.begin(), v.end(), MyPrint());
	cout << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.4.4 swap

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 swap
void myPrint(int val)
{
	cout << val<<" ";
}
void test01()
{
	vector<int>v1;
	vector<int>v2;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 100);
	}
	cout << "交换前：" << endl;
	for_each(v1.begin(), v1.end(), myPrint);
	for_each(v2.begin(), v2.end(), myPrint);
	cout << endl;

	cout << "----------------------" << endl;
	swap(v1, v2);
	cout << "交换前：" << endl;
	for_each(v1.begin(), v1.end(), myPrint);
	for_each(v2.begin(), v2.end(), myPrint);
	cout << endl;

}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述

4.5 常用算术生成算法

在这里插入图片描述

4.5.1 accumulate

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<numeric>
//常用算术生成算法
void test01()
{
	vector<int>v;

	for (int i = 0; i <= 100; i++)
	{
		v.push_back(i);
	}
	//参数3 起始累加值
	int total=accumulate(v.begin(), v.end(), 0);
	cout << "total=" << total << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述

4.5.2 fill

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<numeric>
#include<algorithm>
//常用算术生成算法 fill
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vector<int>v;
	v.resize(10);

	//后期重新填充
	fill(v.begin(), v.end(), 100);
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
	
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述

在这里插入图片描述

4.6 常用集合算法

在这里插入图片描述

4.6.1 set_intersection

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

//常用集合算法 set_intersection
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);//0~9
		v2.push_back(i + 5);//5~14
	}

	vector<int>vTarget;
	//目标容器需要提前开辟空间  
	//最特殊情况  大容器包含小容器 开辟空间 取小容器的size即可
	vTarget.resize(min(v1.size(), v2.size()));

	//获取交集
	vector<int>:: iterator itEnd= set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint);
	cout << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.6.2 set_union

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

//常用集合算法 set_union
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);//0~9
		v2.push_back(i + 5);//5~14
	}

	vector<int>vTarget;
	//目标容器提前开辟空间
	//最特殊的情况 俩个容器没有交集，并集就是俩个容器size相加
	vTarget.resize(v1.size() + v2.size());
	vector<int>::iterator itEnd= set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint);
	cout << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

4.6.3 set_difference

在这里插入图片描述

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

//常用集合算法 set_difference
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);//0~9
		v2.push_back(i + 5);//5~14
	}

	vector<int>vTarget;
	//目标容器提前开辟空间
	//最特殊的情况 俩个容器没有交集，取两个容器中大的size作为目标容器开辟空间
	vTarget.resize(max(v1.size() ,v2.size()));
	cout << "v1和v2的差集为：" << endl;
	vector<int>::iterator itEnd= set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint);
	cout << endl;
	cout << "v2和v1的差集为：" << endl;
	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint);
	cout << endl;
}

int main()
{
	test01();
	
	return 0;
}

在这里插入图片描述
在这里插入图片描述

摸鱼儿Tao
关注
专栏目录
黑马程序员C++学习笔记
weixin_46015291的博客
05-31 5070
C++基础入门 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using namespace std; int main() { cout &
c++学习笔记.pdf
07-12
C++是一种静态类型、编译式、通用的编程语言，它支持过程化编程、面向对象编程和泛型编程。C++广泛应用于软件开发领域，包括操作...以上内容覆盖了C++语言中一些基础知识点，对于学习和理解C++编程具有重要的指导意义。
C++ 学习笔记
weixin_42098295的博客
04-29 1546
继承可以让新的类继承现有类的特性，多态通过接口的多种实现提供了函数行为的多样性，而封装则隐藏了数据的内部表示，只暴露必要的操作接口，这有助于减少系统的复杂性并提高其安全性。内存管理还涉及到堆和栈的使用，其中栈用于存储局部变量和函数调用的信息，而堆则用于动态内存分配，通常由程序员手动管理，这在处理大量数据或不确定数据大小时特别有用。在组织大型程序时，命名空间提供了避免名字冲突的方式，使得相同名字的变量或函数可以在不同的命名空间下共存，极大地增强了代码的模块化和可维护性。，用来存储数字、字符和布尔值。
C++学习笔记
热门推荐
ftm_csdn的博客
04-16 1万+
C++是C语言的超集。
c++学习笔记1
最新发布
resco的博客
10-04 1391
c++的学习开始啦
c++学习笔记
weixin_54948102的博客
02-06 416
自用笔记。
C++学习笔记——typedef和using
耶律大石的博客
02-06 1550
using更为灵活，在现代C++中更受推荐，特别是在需要创建模板类型别名的情况下。typedef在兼容较旧代码、较旧C++标准的情况下仍然有其价值，但对于现代C++来说，using更适用。
z3 C++学习笔记
T_T233333333的博客
03-06 3830
因为项目需要使用z3库来解决问题，所以自己学习了一下，结果发现网上教程比较少，而且大部分都是使用Python，而我本人是C++的忠实信徒，在知道C++也可以使用z3库以后我毫不犹豫地着手用C++使用z3，但是我很快发现，网上基本没有关于C++使用z3的教程（中文社区一点都没有），因此我记录一下我自己的学习过程希望能够帮助到其他学习的人。 教程链接 网上现有的有三个教程： 官方example.cpp文档：https://github.com/Z3Prover/z3/blob/master/examples.
C++学习笔记——菲波那契数
ssismm的博客
08-27 738
【代码】C++学习笔记——菲波那契数。
C++学习笔记（超详细笔记记录ing）
weixin_56868328的博客
02-14 1070
C++学习笔记（1）C++基础语法：编写程序，注释，变量，常量，数据类型...
C++学习笔记——鸡兔同笼
ssismm的博客
08-26 674
【代码】C++学习笔记——鸡兔同笼。
c++学习笔记精华版
08-27
### C++ 学习笔记精华版 #### 一、C++ 语言概述 **1、历史背景** - **C++ 的江湖地位** - Java、C、C++、Python、C# 是当前主流的编程语言之一，而 C++ 在这些语言中以其高效性和灵活性著称。 - **C++ 之父 ...
C++学习笔记.pdf
08-12
C++学习笔记
【C++学习笔记】一份详细的学习笔记，让你轻松掌握C++编程！
06-04
【C++学习笔记】这份详尽的资源是为那些希望深入了解C++编程语言的人们精心准备的。C++是一种强大的、通用的编程语言，它的设计理念是面向对象，同时支持过程化编程，使得它在系统软件、应用软件、游戏开发、设备...
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
pytorch学习笔记
lt405514623的博客
11-21 1626
Pytorch学习1 加载数据初识2 TensorBorad的使用2.1 add_scalar()的使用2.1 add_image()的使用2.3 torchvision 中的transforms2.4 常见的Transforms2.4.1 ToTensor Normalize2.4.2 Resize Compose RandomCrop3 torchvision中的数据集使用4 DataLoader的使用5 神经网络的基本骨架-nn.Module的使用6 卷积操作7 神经网络卷积层 1 加
关于Python编程学习 类中出现的错误：TypeError：Dog（）takes no arguments
lt405514623的博客
01-07 1111
按照书本上的输入： 会显示出现错误： 经过多方查找资料，最终得到的正确输入：
8Python 学习笔记 最新 最详细
lt405514623的博客
01-17 945
8. 类 8.1创建Dog类 根据Dog类创建的每个实例都将存储名字和年龄，我们赋予了每条小狗蹲下（sit（））和打滚（roll_over())的能力： 第一行处定义了一个名为Dog的类。根据约定，在Python中，首字母大写的名称指的是类。这个类定义中没有圆括号，因为要从空白创建这个类。   方法_init_() 类中的函数称为方法。方法_init_()是一个特殊方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和结尾各有两个下划线，这是一种约定，旨在避免Pyth
算法学习3
lt405514623的博客
05-03 531
算法01背包问题2 完全背包问题 01背包问题 #pragma warning(disable:4996) #include<cstring> #include<iostream> #include<unordered_set> using namespace std; const int N = 1010; int n, m; int v[N], w[N]; int f[N][N]; //f[i][j]表示[1,i]物品任取放入容量为j的背包 int main(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值