C++ 学习笔记9

目录

• 1 STL初识
• • 1.1 STL的诞生
  • 1.2 STL基本概念
  • 1.3 STL六大组件
  • 1.4 STL中容器、算法、迭代器
  • 1.5 容器算法迭代器初识
  • • 1.5.1 vector存放内置数据类型
    • 1.5.2 Vector存放自定义数据类型
    • 1.5.3 Vector容器嵌套容器
    • 1.5.4 string基本概念
    • 1.5.5 string构造函数
    • 1.5.6 string赋值操作
    • 1.5.7 string字符串拼接
    • 1.5.8 string查找和替换
    • 1.5.9 string字符串比较
    • 1.5.10 string字符存取
    • 1.5.11 string插入和删除
    • 1.5.11 string子串
  • 1.6 vector容器
  • • 1.6.1 vector基本概念
    • 1.6.2 vector构造函数
    • 1.6.3 vector赋值操作
    • 1.6.4 vector容量和大小
    • 1.6.5 vector插入和删除
    • 1.6.6 vector数据存取
    • 1.6.7 vector互换容器
    • 1.6.8 vector预留空间
  • 1.7 deque容器
  • • 1.7.1 deque容器基本概念
    • 1.7.2 deque构造函数
    • 1.7.3 deque赋值操作
    • 1.7.4 deque大小操作
    • 1.7.5 deque插入和删除
    • 1.7.6 deque数据存取
    • 1.7.7 deque排序
  • 1.8 案例-评委打分
  • 1.9 stack容器
  • • 1.9.1 stack基本概念
    • 1.9.2 stack 常用接口
  • 1.10 queue容器
  • • 1.10.1 queue基本概念
    • 1.10.2 queue常用接口
  • 1.11 list容器
  • • 1.11.1 list基本概念
    • 1.11.2 list构造函数
    • 1.11.3 list赋值和交换
    • 1.11.4 list大小操作
    • 1.11.5 list插入和删除
    • 1.11.6 list数据存取
    • 1.11.7 list 反转和排序
    • 1.11.8 排序案例
  • 1.12 set/multiset容器
  • • 1.12.1 set基本概念
    • 1.12.2 set大小和交换
    • 1.12.3 set插入和删除
    • 1.12.4 set查找和统计
    • 1.12.5 set和multiset区别
    • 1.12.5 pair对组创建
    • 1.12.6 set容器排序
  • 1.13 map/multimap容器
  • • 1.13.1 map基本概念
    • 1.13.2 map构造和赋值
    • 1.13.3 map大小和交换
    • 1.13.4 map插入和删除
    • 1.13.5 map查找和统计
    • 1.13.6 map容器排序
    • 1.14 案例
• 2 STL-函数对象
• • 2.1 函数对象
  • • 2.1.1 函数对象概念
    • 2.1.2 函数对象使用
  • 2.2 谓词
  • • 2.2.1谓词概念
    • 2.2.2 一元谓词
    • 2.2.3 二元谓词
  • 2.3 内键函数对象
  • • 2.3.1 内键函数对象意义
    • 2.3.2 算术仿函数
    • 2.3.3 关系仿函数
    • 3.3.4 逻辑仿函数
• 4 STL-算法
• • 4.1 常用遍历算法
  • • 4.1.1 for_each
    • 4.1.2 transform
  • 4.2 常用查找算法
  • • 4.2.1 find
    • 4.2.2 find_if
    • 4.2.2 adjacent_find
    • 4.2.4 binary_search
    • 4.2.5 count
    • 4.2.6 count_if
  • 4.3 常用排序算法
  • • 4.3.1 sort
    • 4.3.2 random_shuffle
    • 4.3.3 merge
    • 4.3.4 reverse
  • 4.4 常用拷贝和替换算法
  • • 4.4.1 copy
    • 4.4.2 replace
    • 4.4.3 replace_if
    • 4.4.4 swap
  • 4.5 常用算术生成算法
  • • 4.5.1 accumulate
    • 4.5.2 fill
  • 4.6 常用集合算法
  • • 4.6.1 set_intersection
    • 4.6.2 set_union
    • 4.6.3 set_difference

1 STL初识 1.1 STL的诞生

1.2 STL基本概念

1.3 STL六大组件

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

1.5 容器算法迭代器初识

1.5.1 vector存放内置数据类型

#include
using namespace std;
#include
#include
#include
//vector容器存放内置数据类型

void myPrint(int val)
{
	cout << val << endl;
}
void test01()
{
	//创建了一个vector容器，数组
	vector v;

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

	//通过迭代器访问容器中的数据
	vector::iterator itBegin = v.begin();//起始迭代器  指向迭代器中第一个元素
	vector::iterator itEnd = v.end(); //结束迭代器     指向容器中最后一个元素的下一个位置

	//第一种遍历方式
	while (itBegin != itEnd)
	{
		cout << *itBegin << endl;
		itBegin++;
	}

	//第二种遍历方式
	for (vector::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
using namespace std;
#include
#include

//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()
{
	vectorv;

	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::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()
{
	vectorv;

	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::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
using namespace std;
#include
#include

//容器嵌套容器
void test01()
{
	vector>v;

	//创建小容器
	vectorv1;
	vectorv2;
	vectorv3;
	vectorv4;

	//向小容器中添加数据
	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>::iterator it = v.begin(); it != v.end(); it++)
	{
		//(*it)----容器vector
		for (vector::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
using namespace std;
#include
#include

//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赋值操作


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
using namespace std;
#include
#include

//string字符串拼接


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
using namespace std;
#include
#include

//字符串查找和替换

//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
using namespace std;
#include
#include

//字符串比较

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& v)
{
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " " << endl;
	}
}
//vector容器构造
void test01()
{
	vectorv1;//默认构造 无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	//通过区间方式进行构造
	vectorv2(v1.begin(), v1.end());
	printVector(v2);

	//n个elem方式构造
	vectorv3(10, 100);
	printVector(v3);

	//拷贝构造
	vectorv4(v3);
	printVector(v4);


}

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

1.6.3 vector赋值操作

void printVector(vector& v)
{
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
//vector赋值
void test01()
{
	vectorv1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	//赋值  operator=
	vectorv2;
	v2 = v1;
	printVector(v2);

	//assign
	vectorv3;
	v3.assign(v1.begin(), v1.end());
	printVector(v3);

	//n个elem方式赋值
	vectorv4;
	v4.assign(10, 100);
	printVector(v4);
}

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

1.6.4 vector容量和大小

void printVector(vector& v)
{
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
//vector容器的容量和大小操作
void test01()
{
	vectorv1;
	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插入和删除

void printVector(vector& v)
{
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	vectorv1;
	//尾插
	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()
{
	vectorv1;
	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& v)
{
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	vectorv1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "交换前：" << endl;
	printVector(v1);

	vectorv2;
	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() {
	vectorv;
	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(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()
{
	vectorv;

	//利用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& d)
{
	for (deque::const_iterator it = d.begin(); it != d.end(); it++)
	{
		/
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& 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& v)
{
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		//将评委的分数 放入到deque容器中
		dequed;
		for (int i = 0; i < 10; i++)
		{
			int score = rand() % 41 + 60;//60~100
			d.push_back(score);
		}
		
		//排序
		sort(d.begin(), d.end());

		//去除最高和最低分
		d.pop_back();
		d.pop_front();

		//取平均分
		int sum = 0;
		for (deque::iterator dit = d.begin(); dit != d.end(); dit++)
		{
			sum += *dit;//累加每个评委的分数
		}
		int avg = sum / d.size();

		//将平均分  赋值给选手身上
		it->m_Score = avg;
	}
}
void showScore(vector&v)
{
	for (vector::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名选手
	vectorv;//存放选手容器
	creatPerson(v);

	//测试
	
	//2、给5名选手打分
	setScore(v);
	//3、显示最后得分
	showScore(v);
	return 0;
}

1.9 stack容器 1.9.1 stack基本概念

1.9.2 stack 常用接口

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

	//入栈
	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
using namespace std;
#include
#include

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

	//准备数据
	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
using namespace std;
#include
#include
//list容器构造函数

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

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

	//遍历容器
	printList(L1);

	//区间方式构造
	listL2(L1.begin(), L1.end());
	printList(L2);

	//拷贝构造
	listL3(L2);
	printList(L3);

	//n个elem
	listL4(10, 1000);
	printList(L4);
}




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

1.11.3 list赋值和交换

#include
using namespace std;
#include
#include
//list容器赋值和交换

void printList(const list& L)
{
	for (list::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
//赋值
void test01()
{
	listL1;

	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	printList(L1);

	listL2;
	L2 = L1;//operator= 赋值
	printList(L2);

	listL3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);

	listL4;
	L4.assign(10, 100);
	printList(L4);

}
//交换
void test02()
{
	listL1;

	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	listL2;
	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
using namespace std;
#include
#include
//list容器大小操作

void printList(const list& L)
{
	for (list::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	listL1;

	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的元素个数为：" < 

 
 
1.11.5 list插入和删除 
 
#include
using namespace std;
#include
#include
//list容器插入和删除

void printList(const list& L)
{
	for (list::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	listL;
	//尾插
	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::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
using namespace std;
#include
#include
//list容器  数据存取

void printList(const list& L)
{
	for (list::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	listL1;
	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::iterator it = L1.begin();
	it++;//支持双向
	it--;
	//it=it+1;//不支持随机访问

}

int main()
{
	test01();
	
	return 0;
}
 
 
1.11.7 list 反转和排序 
 
#include
using namespace std;
#include
#include
//list容器反转和排序

void printList(const list& L)
{
	for (list::const_iterator it = L.begin(); it != L.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	//反转
	listL1;
	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()
{
	listL1;
	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
using namespace std;
#include
#include
//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()
{
	listL;//创建容器

	//准备数据
	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::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::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
using namespace std;
#include
#include

//set容器构造和赋值
void printSet(set& s)
{
	for (set::iterator it = s.begin(); it != s.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	sets1;
	//插入数据 只有insert方式
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(30);
	s1.insert(30);

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

	//拷贝构造
	sets2(s1);
	printSet(s2);

	//赋值
	sets3;
	s3 = s2;
	printSet(s3);
}
int main()
{
	test01();

	return 0;
}
 
 
1.12.2 set大小和交换 
 
#include
using namespace std;
#include
#include

//set容器 大小和交换


void printSet(set& s)
{
	for (set::iterator it = s.begin(); it != s.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
//大小
void test01()
{
	sets1;
	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()
{
	sets1;

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

	sets2;

	//插入数据
	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
using namespace std;
#include
#include

//set容器 插入和删除


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

void test01()
{
	sets1;

	//插入
	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
using namespace std;
#include
#include

//set容器 查找和统计


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

void test01()
{
	//查找
	sets1;

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

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

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

}
void test02()
{
	//查找
	sets1;
	//插入数据
	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
using namespace std;
#include
#include

//set容器 和 multiset容器区别


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

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

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


int main()
{
	test01();

	
	return 0;
}
 

 
 
1.12.5 pair对组创建 
 
#include
using namespace std;
#include
#include

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

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


int main()
{
	test01();

	
	return 0;
}
 
 
1.12.6 set容器排序 
#include
using namespace std;
#include
#include

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

	//指定排序规则为从大到小
	sets2;

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

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


int main()
{
	test01();

	
	return 0;
}
 
 
#include
using namespace std;
#include
#include

//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()
{
	//自定义数据类型  都会指定排序规则
	sets;

	//创建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::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
using namespace std;
#include
#include
 

 
 
1.13.3 map大小和交换 
 
#include
using namespace std;
#include
#include
 
 
1.13.4 map插入和删除 
 
#include
using namespace std;
#include
#include
 

 
 
1.13.5 map查找和统计 
 
#include
using namespace std;
#include
#include
 

 
 
1.13.6 map容器排序 
 
#include
using namespace std;
#include
#include
 

 
 
1.14 案例 
 
#include
using namespace std;
#include
#include
#include
 
 
2 STL-函数对象 
2.1 函数对象 
2.1.1 函数对象概念 
 
2.1.2 函数对象使用 
 
#include
using namespace std;
#include

//函数对象（仿函数）
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
using namespace std;
#include
#include
#include
//仿函数 返回值类型是bool数据类型，称为谓词
//一元谓词
class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};
void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//查找容器中 有没有大于5的数字
	//GreaterFive() 匿名函数对象
	vector::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
using namespace std;
#include
#include
#include

//二元谓词
class MyCompare
{
public:
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}
};
void test01()
{
	vectorv;
	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::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it <<" ";
	}
	cout << endl;

	//使用函数对象  改变算法策略 ，变为排序规则为从大到小
	sort(v.begin(), v.end(), MyCompare());
	for (vector::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
using namespace std;
#include //内建函数对象头文件


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

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

void test01()
{
	negaten;
	cout << n(50) << endl;
}

//plus 二元仿函数 加法
void test02()
{
	plusp;
	cout << p(10, 20) << endl;
}
int main()
{
	test01();
	test02();
	return 0;
}
 
 
2.3.3 关系仿函数 
 
#include
using namespace std;
#include //内建函数对象头文件
#include
#include
#include

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

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

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


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

 
 
3.3.4 逻辑仿函数 
 
#include
using namespace std;
#include //内建函数对象头文件
#include
#include
#include

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

	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	//利用逻辑非，将容器v搬运到 容器v2中，并执行取反操作
	vectorv2;
	v2.resize(v.size());
	transform(v.begin(), v.end(), v2.begin(), logical_not());
	for (vector::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
using namespace std;
#include 
#include
#include
#include

//常用遍历算法 for_each

//普通函数
void print01(int val)
{
	cout << val << " ";
}
//仿函数
class print02
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vectorv;
	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
using namespace std;
#include 
#include
#include
#include

//常用遍历算法 transform

class Transform
{
public:
	int operator()(int v)
	{
		return v;
	}
};
class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	
	vectorvTagrget;//目标容器
	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
using namespace std;
#include
#include
#include
//常用查找算法
//find

//查找 内置数据类型
void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//查找 容器中 是否有 5 这个元素
	vector::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()
{
	vectorv;
	//创建数据
	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::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
using namespace std;
#include
#include
#include
//常用查找算法 find_if

//1、查找内置数据类型
class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};
void test01()
{
	vectorv;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	vector::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()
{
	vectorv;
	//创建数据
	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::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
using namespace std;
#include
#include
#include
//常用查找算法 adjacent_find


void test01()
{
	vectorv;
	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::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
using namespace std;
#include
#include
#include
//常用查找算法 binary_search

void test01()
{
	vectorv;
	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
using namespace std;
#include
#include
#include
//常用查找算法 count

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

void test01()
{
	vectorv;
	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()
{
	vectorv;
	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
using namespace std;
#include
#include
#include
//常用查找算法 count_if

//1、统计内置数据类型
class Greater20
{
public:
	bool operator()(int val)
	{
		return val > 20;
	}
};
void test01()
{
	vectorv;
	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()
{
	vectorv;
	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
using namespace std;
#include
#include
#include
//常用排序算法 sort
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vectorv;
	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());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;

	
}

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

 
 
4.3.2 random_shuffle 
 
#include
using namespace std;
#include
#include
#include
//常用排序算法 random_shuffle
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	srand((unsigned int)time(NULL));
	vectorv;
	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
using namespace std;
#include
#include
void myPrint(int val)
{
	cout << val << " ";
}
//常用排序算法 merge
void test01()
{
	vectorv1;
	vectorv2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 1);
	}
	//目标容器
	vectorvTarget;
	//提前给目标容器分配空间
	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
using namespace std;
#include
#include
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vectorv;
	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
using namespace std;
#include
#include
//常用拷贝和替换算法 copy
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vectorv1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	vectorv2;
	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
using namespace std;
#include
#include
//常用拷贝和替换算法 replace
class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vectorv;
	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
using namespace std;
#include
#include
//常用拷贝和替换算法 replace_if
class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
class Greater30
{
public:
	bool operator()(int val)
	{
		return val >= 30;
	}
};
void test01()
{
	vectorv;
	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
using namespace std;
#include
#include
//常用拷贝和替换算法 swap
void myPrint(int val)
{
	cout << val<<" ";
}
void test01()
{
	vectorv1;
	vectorv2;

	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
using namespace std;
#include
#include
//常用算术生成算法
void test01()
{
	vectorv;

	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
using namespace std;
#include
#include
#include
//常用算术生成算法 fill
void myPrint(int val)
{
	cout << val << " ";
}
void test01()
{
	vectorv;
	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
using namespace std;
#include
#include

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

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

	//获取交集
	vector:: 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
using namespace std;
#include
#include

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

	vectorvTarget;
	//目标容器提前开辟空间
	//最特殊的情况 俩个容器没有交集，并集就是俩个容器size相加
	vTarget.resize(v1.size() + v2.size());
	vector::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
using namespace std;
#include
#include

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

	vectorvTarget;
	//目标容器提前开辟空间
	//最特殊的情况 俩个容器没有交集，取两个容器中大的size作为目标容器开辟空间
	vTarget.resize(max(v1.size() ,v2.size()));
	cout << "v1和v2的差集为：" << endl;
	vector::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;
}