1 模板

1.1 模板的概念

建立通用的模板，提高代码复用性

1.2 函数模板

·c++还有一种利用模板的泛型编程

1. 语法

建立函数，其返回值类型和形参类型用虚拟类型代表

template<typename T>

// 函数模板
template<typename T>    //  声明一个模板，T是通用数据类型
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test()
{
	int a = 10;
	int b = 20;
	// 1.自动类型推导
	mySwap(a, b);
	mySwap<int>(a, b);
	// 2.显示指定类型
	cout << "a:" << a << endl;
	cout << "b:" << b << endl;
}

将类型参数化

2.注意事项

·自动类型推导：必须推导出一致的数据类型T

·模板必须确定出T的数据类型才可以使用

3.模板案例

// 交换函数模板
template<class T>
void myswap(T &a, T &b)
{
	int temp = a;
	a = b;
	b = temp;
}
// 排序算法
template<typename T>    //  声明一个模板，T是通用数据类型
void mySort(T arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		int max = i;    // 认定最大值的下标
		for (int j = i+1; j < len; j++)
		{
			if (arr[max] < arr[j])   // 认定的最大值比便利出的值小
			{
				max = j;
			}
		}
		if (max != i)
		{
			myswap(arr[max], arr[i]);
		}
	}
}

void test()
{
	char chararr[] = "cabdjukadn";
	int num = sizeof(chararr) / sizeof(char);
	mySort(chararr, num);
	for (int i = 0; i < num; i++)
	{
		cout << chararr[i];
	}
	cout << endl;
}

4.普通函数与函数模板区别

·普通函数调用时可以发生隐式类型转换

·函数模板调用时，若利用自动类型推导，不会发生隐式类型转换

·若利用显示指定类型的方式，可以发生隐式类型转换（建议使用）

5.普通函数与函数模板的调用规则

·若函数模板和普通函数都可以实现，优先调用普通函数

·可通过空模板参数列表来强制调用函数模板

·函数模板可以发生重载

·若函数模板可以产生更好的匹配，优先调用函数模板

提供函数模板后不要提供普通函数，避免产生二义性

6.模板的局限性

模板不是万能的。无法实现自定义数据类型的通用化，需要利用模板重载具体化数据类型

// myCompare 为模板，进行重载
template<> bool myCompare(Person &a,Person &b)

1.3 类模板

1.语法

与函数模板大体一致

// 类模板
template<class Nametype,class Agetype>
class Person
{
public:
	Person(Nametype name, Agetype age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	Nametype m_name;
	Agetype m_age;
};

2.类模板与函数模板的区别

·类模板中没有自动类型推导的方式

·类模板在模板参数列表中可以有默认参数

3.类模板中成员函数创建时机

·普通成员函数一开始创建

·类模板中成员函数在调用时创建

4.类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式：

·指定传入的类型：直接显示对象的数据类型

// 类模板对象做函数参数
template<class Nametype, class Agetype>
class Person
{
public:
	Person(Nametype name, Agetype age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void showPerson()
	{
		cout << "name:" << this->m_name << endl;
		cout << "age:" << this->m_age << endl;
	}
	Nametype m_name;
	Agetype m_age;
};
// 1.指定传入类型
void printPerson1(Person<string, int>&p)
{
	p.showPerson();
}
void test01()
{
	Person<string, int>p("sun", 100);
	printPerson1(p);
}

·参数模板化：将对象中的参数变为模板进行传递

// 2.参数模板化
template<class Nametype,class Agetype>
void printPerson2(Person<Nametype, Agetype>&p)
{
	p.showPerson();
}
void test02()
{
	Person<string, int>p("zhu", 99);
	printPerson2(p);
}

·整个类模板化：将这个对象类型模板化进行传递

// 3.整个类模板化
template<class T>
void printPerson3(T &p)
{
	p.showPerson();
}
void test03()
{
	Person<string, int>p("sha", 90);
	printPerson3(p);
}

5.类模板与继承

·子类继承的父类为类模板时，子类在声明的时候，要指定父类T的类型，否则无法给子类分配内存

// 类模板与继承
template<class T>
class Base
{
	T m;
};
class son:public Base<int>
{

};

·若需灵活指定父类T类型，子类需变为类模板

// 类模板与继承
template<class T>
class Base
{
	T m;
};
template<class T1,class T2>
class son:public Base<T2>
{
	T1 obj;
};

6.类模板成员函数类外实现

类外实现时，类内只写函数声明

// 类模板成员函数类外实现
template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	void show();

	T1 m_name;
	T2 m_age;
};
// 构造函数的类外实现
template<class T1, class T2>
Person<T1,T2>::Person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}
template<class T1, class T2>
// 成员函数类外实现
void Person<T1, T2>::show()
{
	cout << "姓名：" << this->m_name << "年龄：" << this->m_age << endl;
}

7.类模板分文件编写

类模板中成员函数创建时机在调用阶段，导致分文件编写时链接不到

void test()
{
	Person<string, int>P("time", 20);
	P.show();
}

类的声明在头文件中，类的实现在源文件中。此时主函数中调用上述代码会报错。

解决方法1：直接包含.cpp源文件

#include<iostream>
using namespace std;
#include<string>
#include"Person.cpp"

解决方法2：将声明和实现写到同一个文件中，更改后缀名为.hpp

#include"Person.hpp"

8.类模板与友元

全局函数类内实现：在类内声明友元

全局函数类外实现：提前让编译器得知全局函数的存在

// 让编译器提前获取类外函数
template<class T1, class T2>
class Person;

template<class T1, class T2>
void PrintPerson(Person<T1, T2>p)
{
	cout << "姓名：" << p.m_name << "年龄：" << p.m_age << endl;
}
// 通过全局函数打印信息
template<class T1,class T2>
class Person
{
	// 友元函数类外实现
	// 添加空模板的参数列表
	friend void PrintPerson<>(Person<T1, T2>p);
public:
	Person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
private:
	T1 m_name;
	T2 m_age;
};

9.类模板案例

在.hpp文件中编写类模板

#pragma once
#include<iostream>
using namespace std;
#include<string>
// 通用数组类
template<class T>
class myArray
{
public:
	// 有参构造 参数 容量
	myArray(int capacity)
	{
		//cout << "有参构造调用" << endl;
		// 属性初始化
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];    // 按照容量大小开辟堆区空间
	}
	// 拷贝构造（防止浅拷贝）
	myArray(const myArray& arr)
	{
		//cout << "拷贝构造调用" << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;        // 指针不能直接赋值，否则会产生浅拷贝
		// 深拷贝
		this->pAddress = new T[arr.m_Capacity];     
		// 拷贝arr中数据
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}
	myArray& operator=(const myArray& arr)
	{
		//cout << "operator=调用" << endl;
		// 先判断堆区是否有数据，若有先释放
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}
		// 深拷贝
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[arr.m_Capacity];
		// 拷贝arr中数据
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}
	// 尾插法
	void pushBack(const T & val)
	{
		// 判断容量是否等于大小
		if (this->m_Capacity == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val;   // 在数组末尾插入数据
		this->m_Size++;    // 更新数组大小
	}
	// 尾删法
	void popBack()
	{
		// 让用户无法访问末尾
		if (this->m_Size==0)
		{
			return;
		}
		this->m_Size--;
	}
	// 通过下标访问数组元素
	T& operator[](int index)       // operator重载运算符[]
	{
		return this->pAddress[index];
	}
	// 返回数组容量
	int getCapacity()
	{
		return this->m_Capacity;
	}
	// 返回数组大小
	int getSize()
	{
		return this->m_Size;
	}
	
	// 析构函数
	// 释放堆区空间
	~myArray()
	{
		//cout << "析构函数调用" << endl;
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;           // 置空防止野指针
		}
	}
private:
	T * pAddress;       // 指针指向堆区开辟的真实数组
	int m_Capacity;     // 数组容量
	int m_Size;         // 数组大小
};

其中：构造函数为初始化、拷贝构造防止浅拷贝、operator=重载操作符防止浅拷贝、析构函数清空堆区内容。

源文件

#include<iostream>
using namespace std;
#include<string>
#include"myArray.hpp"
void printIntArray(myArray<int>&arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << arr[i] << endl;
	}
}
void test()
{
	myArray<int>arr1(5);
	for (int i = 0; i < 5; i++)
	{
		arr1.pushBack(i);
	}
	printIntArray(arr1);
	cout << "arr1的容量" << arr1.getCapacity() << endl;
	cout << "arr1的大小" << arr1.getSize() << endl;
	
	myArray<int>arr2(arr1);
	printIntArray(arr2);
	arr2.popBack();
	cout << "arr2尾删后的容量" << arr2.getCapacity() << endl;
	cout << "arr12尾删后的大小" << arr2.getSize() << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

2 STL初始

2.1 STL基本概念

1.概念：STL（standard template library，标准模板库）

2.STL从广义上分为：容器、算法、迭代器

3.容器和算法间通过迭代器连接

2.2 STL组件

1.容器：各类数据结构

2.算法：各类常用算法

3.迭代器：容器与算法间的桥梁

4.仿函数：行为类似函数

5.适配器：修饰容器或仿函数或迭代器接口

6.空间配置器：空间配置与管理

2.3 STL容器、算法及迭代器

1.容器分为序列式容器（强调值的排序，序列式容器中每个元素均有固定位置）与关联式容器（二叉树结构，各元素间没有严格物理上的顺序关系）

2.算法分为质变算法（运算期间会更改区间元素内容）和非质变算法（运算期间不会更改区间元素内容）

3.迭代器种类

2.4 容器算法、迭代器初识

1.vector存放内置数据类型

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<algorithm>
// vector容器存放内置数据类型
void myPrint(int val)
{
	cout << val << endl;
}
void test()
{
	// 创建vector容器，可认为是数组
	vector<int> v;
	// 向容器中插入数据
	v.push_back(10);
	v.push_back(1200);
	v.push_back(120);
	
	// 第一种遍历方式
	// 通过迭代器访问容器中的数据
	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;
	}
	// 第三种遍历方式，利用遍历算法
	for_each(v.begin(), v.end(), myPrint);
}

2.vector存放自定义数据类型

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

void test()
{
	// 创建vector容器
	vector<Person> v;
	Person p1("a", 10);
	Person p2("b", 20);
	Person p3("c", 30);

	// 向容器中添加数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	
	// 通过迭代器访问容器中的数据
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名：" <<(*it).name<< " 年龄："<<(*it).age << endl;
		// 以下相同
		//cout << "姓名：" << it->name<< " 年龄：" << it->age << endl;
	}
}
// 存放自定义数据类型的指针
void test01()
{
	// 创建vector容器
	vector<Person*> v;
	Person p1("a", 10);
	Person p2("b", 20);
	Person p3("c", 30);

	// 向容器中添加数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);

	// 遍历
	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名：" << (*it)->name << " 年龄：" << (*it)->age << endl;
	}
}

3.vector容器嵌套

// vector容器嵌套
void test()
{
	// 创建vector容器
	vector<vector<int>> v;
	// 创建内层容器
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
	}
	// 创建外层容器
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	// 通过迭代器访问容器中的数据
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit;
		}
		cout << endl;

	}
}

3 STL常用容器

3.1 string容器

1.string概念

string本质上是个类，是一个char*型的容器。类内提供了多种成员方法

2.string构造函数

string();   默认构造

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

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

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

3.string赋值操作

 常用前三种方式赋值

    // 方法1
	string str1;
	str1 = "hello";

	// 方法2
	string str2;
	str2 = str1;

	// 方法3
	string str3;
	str3 = 'a';

	// 方法4
	string str4;
	str4.assign("hello");

	// 方法5
	string str5;
	str5.assign("hello", 4);

	// 方法6
	string str6;
	str6.assign(str5);

	// 方法7
	string str7;
	str7.assign(10, '7');

4.string字符串拼接

	// 方法1
	string str1 = "hello";
	str1 += "world";

	// 方法2
	string str2 = "!";
	str1 += str2;

	// 方法3
	string str3 = "hello";
	str3.append("world");

	// 方法4
	string str4 = "hello";
	str4.append("hello",4);

	// 方法5
	string str5 = "hello";
	str5.append(str2);

	// 方法6
	string str6;
	str6.append(str5,0,3);

5.string查找和替换

	// 查找
	// 方法1
	string str1 = "hello";
	str1.find("l");   // 若存在返回1，否则返回-1

	// 方法2
	str1.rfind("l");   // rfind从右往左查，find查找顺序相反

	// 替换
	str1.replace(1,3,"11");

6.string字符串比较

字符串以ASCii大小进行比较，相等返回0，大于返回1，小于返回-1

	// 字符串比较
	string str1 = "hello";
	string str2 = "hello";
	if (str1.compare(str2) == 0)
	{
		cout << "相等" << endl;
	}

7.string存取

	// 字符串存取
	string str = "hello world";
	// 方法1：通过[]访问单个字符
	for (int i = 0; i < str.size(); i++)

	{
		cout << str[i] << endl;
	}
	// 方法2通过at方式
	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << endl;
	}

8.string插入和删除

	// 字符串插入与删除
	string str = "hello world";
	
	str.insert(1, "11");   // 插入

	str.erase(1, 2);      // 删除

9.string子串

	// 字符串子串获取
	string str = "hello world";
	
	string subStr = str.substr(1, 3);

3.2 vector容器

1.vector概念

vector与数组类似，称为单端数组；不同于数组是静态空间，vector可以动态扩展（寻找更大的内存空间，将源数据拷贝至新空间，并释放原空间）

vector容器的迭代器是支持随机访问的迭代器

2.vector构造函数

创建vector容器

	vector<int> v1;     // 无参构造

	vector<int> v2(v1.begin(), v1.end());   // 通过区间方式进行构造

	vector<int> v3(10, 100);    // n个elem方式构造

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

3.vector赋值操作

	// 无参构造
	vector<int> v1;     
    // operator=
	vector<int> v2;
	v2 = v1;         
	// assign
	vector<int> v3;        
	v3.assign(v1.begin(), v1.end());   
	// n个elem赋值
	vector<int> v4;  
	v4.assign(10, 100);

4.vector容量和大小

5.vector插入和删除

6.vector数据存取

7.vector互换容器

swap可以收缩空间

	vector<int> v;  
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	cout << v.capacity() << endl;
	cout << v.size() << endl;
	vector<int>(v).swap(v);
	cout << v.capacity() << endl;
	cout << v.size() << endl;

8.vector预留空间

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

3.3 deque容器

1.deque基本概念

双端数组，可以对头端进行插入删除操作

2.deque构造函数

3.deque赋值操作

4.deque大小操作

5.deque插入和删除

6.deque数据存取

7.deque排序

需包含算法头文件

对于支持随机访问的迭代器的容器（vector），都可利用sort算法直接对其排序。

3.4 案例-评委打分

// 选手类
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<int> d;
		for (int i = 0; i < 10; i++)
		{
			int score = rand() % 41 + 60;
			d.push_back(score);
		}
		// 排序
		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;
	}
}

3.5 stack容器

1.概念

stack是一种先进后出的数据结构，只有一个出口。栈不允许有遍历行为

2.常用接口

3.6 queue容器

1.queue概念

queue是一种先进先出的数据接口，只有队头和队尾才可被访问，不可遍历。

2.queue常用接口

 

3.7 list容器

1.list概念

·将数据进行链式存储

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

·链表由一系列结点组成，结点一个是存储数据元素的数据域，另一个是村查下一个结点地址都指针域

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

·可以对任意位置进行快速插入或删除元素，但遍历速度没有数组快，且占用空间比数组大

 链表中的迭代器只支持前移和后移，属于双向迭代器；

2.list构造函数

3.list赋值和交换

4.list大小操作

5.list插入和删除

6.list数据存取

list不能用[]与at方式访问元素，迭代器不支持随机访问

7.list反转和排序

8.排序案例

// 类定义
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 test()
{
	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;
	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;
	}
}

3.8 set/multiset容器

1.set基本概念

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

·属于关联式容器，底层结构用二叉树实现

·不允许有重复元素

2.set构造和赋值

3.set大小和交换

4.set插入和删除

5.set查找和统计

6.set和multiset区别

7.pair对组创建

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

// 对组的创建
	pair<string, int>p1("tom", 20);
	cout << p1.first << p1.second << endl;
	pair<string, int>p2 = make_pair("jerry", 30);
	cout << p2.first << p2.second << endl;

8.set容器排序

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

·内置数据类型排序

// 仿函数
class mycompare
{
public:
	bool operator()(int v1,int v2)   // 第一个()代表重载符，第二个()代表函数参数列表
	{
		return v1 > v2;
	}
};
void test()
{
	set<int, mycompare>s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(40);
	s1.insert(30);
	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

·自定义数据类型排序

class Person
{
public:
	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
class mycompare
{
public:
	bool operator()(const Person &p1, const Person &p2)   // 第一个()代表重载符，第二个()代表函数参数列表
	{
		return p1.m_age > p2.m_age;
	}
};
void test()
{
	// 自定义数据类型要指定排序规则
	set<Person, mycompare>s;
	Person p1("tom", 24);
	Person p2("jarry", 34);
	Person p3("luffy", 25);
	Person p4("zoro", 14);
	Person p5("sam", 55);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);
	s.insert(p5);

	for (set<Person, mycompare>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << it->m_name <<  " " << it->m_age <<endl;
	}
}

3.9 map/multimap容器

1.map概念

·map中所有元素都是pair

·pair中首个元素为key（键值），起到索引作用，第二个元素为value（实值）

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

·map/multimap属于关联式容器，底层结构式二叉树实现

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

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

2.map构造和赋值

 

数据插入时要使用对组

3.map大小和交换

4.map插入和删除

5.map查找和统计

6.map容器排序

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

3.10 案例-员工分组

// 创建员工类
class Worker
{
public:
	string m_name;
	int m_salary;
};
void creatWorker(vector<Worker> &v)
{
	string workerName = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++)
	{
		Worker worker;
		worker.m_name = workerName[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 deptId = rand() % 3;   // 0 1 2
		m.insert(make_pair(deptId, *it));
	}
}
void showWorker(multimap<int, Worker> &m)
{
	cout << "0号部门成员：" << endl;
	multimap<int, Worker>::iterator pos = m.find(0);
	int count = m.count(0);
	int index = 0;
	for (; pos != m.end() && index < count; pos++,index++)
	{
		cout << "姓名：" << pos->second.m_name << " 工资：" << pos->second.m_salary << endl;
	}

	cout << "1号部门成员：" << endl;
	pos = m.find(1);
	count = m.count(1);
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名：" << pos->second.m_name << " 工资：" << pos->second.m_salary << endl;
	}

	cout << "2号部门成员：" << endl;
	pos = m.find(2);
	count = m.count(2);
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名：" << pos->second.m_name << " 工资：" << pos->second.m_salary << endl;
	}
}

4 STL函数对象

4.1 函数对象

1.函数对象概念

本质上是一个类 

2.函数对象使用

// 仿函数
// 可以像普通函数一样调用，可以有参数值与返回值
class myAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};
void test01()
{
	myAdd a;
	cout << a(10, 10) << endl;
}
// 函数对象可以有自己的状态
class myPrint
{
public:
	myPrint()
	{
		this->count = 0;
	}
	void operator()(string test)
	{
		cout << test << endl;
		this->count++;
	}
	int count;   // 记录内部状态

};
// 函数对象可以作为参数传递

4.2 谓词

1.概念

2.一元谓词

// 一元谓词
// 仿函数
class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};
void test()
{
	vector<int> v;
	for (int i = 0; i <10 ; i++)
	{
		v.push_back(i);
	}
	// 查找是否存在大于5的数字
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());

3.二元谓词

// 二元谓词
// 仿函数
class mycompare
{
public:
	bool operator()(int v1,int v2)
	{
		return v1 > v2;
	}
};
void test()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	v.push_back(50);

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

4.3 内建函数对象

1.内建函数对象

需要添加头文件functional

2.算术仿函数

实现四则运算

	// 一元仿函数
	negate<int> n;
	cout << n(50) << endl;
	// 二元仿函数
	plus<int> p;
	cout << p(10, 20) << endl;

3.关系仿函数

4.逻辑仿函数

5 STL常用算法

5.1 常用遍历算法

·算法头文件：algorithm、functional、numeric

1.for_each

2.transform

搬运容器到另一个容器中，搬运前需要给目标容器开辟空间

5.2 常用查找算法

1.find

按值查找元素

若查找自定义数据类型，需在类中重载==运算符

2.find_if

按条件查找元素

3.adjacent_find

查找相邻重复元素

4.binary_search

查找指定元素是否存在

5.count

统计元素个数

6.count_if

按条件统计元素个数

5.3 常用排序算法

1.sort

 

2.random_shuffle

 

3.merge

4.reverse

5.4 常用拷贝和替换算法

1.copy

 

2.replace

3.replace_if

4.swap

5.5 常用算术生成算法

1.accumulate

2.fill

5.6 常用集合算法

1.set_intersection

2.set_union

3.set_difference

 目标容器开辟空间需要从两个容器取较大值