• 本阶段主要针对C++泛型编程和STL技术

1 模板

1.1 模板的概念

• 模板就是建立通用的模具，提高代码的复用性

1.2 模板的特点

• 模板不能直接使用，他只是一个框架
• 模板的通用并不是万能的

1.3 函数模板

• c++的另外一种编程思想 称为泛型编程，主要利用的技术就是模板。
• C++提供的两种模板机制： 函数模板 和 类模板

1.3.1 函数模板语法

• 函数模板通过建立一个通用函数，其函数返回值类型和形参类型都不用具体指定，而是用一个虚拟的类型来代表。

语法：

#写法一：
template<typename T>
函数声明或定义

#写法二：
template<class T>
函数声明或定义

# template: 声明创建模板
# typename / class  表明其后面的符号T 是一种通用的数据类型
# T 通用数据类型，名称可以替换，通常为大写字母

示例：

//交换整型函数
void swapInt(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}

//交换浮点型函数
void swapDouble(double& a, double& b) {
	double temp = a;
	a = b;
	b = temp;
}

//利用模板提供通用的交换函数
template<typename T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;
	
	//swapInt(a, b);

	//利用模板实现交换
	//1、自动类型推导
	mySwap(a, b);

	//2、显示指定类型
	mySwap<int>(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

• 函数模板利用关键字 template。
• 使用函数模板有两种方式： 自动类型推导 和 显示指定类型。
• 模板的目的是提高复用性，将类型参数化。

1.3.2 函数模板注意事项

注意事项

• 自动类型推导，必须推导出一致的数据类型T，才能够使用。
• 模板必须要确定出T的数据类型，才可以使用。

示例

#include <iostream>
using namespace std;

//利用模板提供通用的交换函数
template<class T>
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

// 1、自动类型推导，必须导出一致的数据类型T，才可以使用
void test01() {
	int a = 10;
	int b = 20;
	char c = 'c';

	mySwap(a, b); // 正确， a和b的类型一致，可以自动推导
	//mySwap(a, c);  // 错误，int 和 char 类型不一致，不能推导出一直的T类型
}

// 2、模板必须要确定出T的类型才能够使用
template <class T>
void func() {
	cout << "func 调用！" << endl;
}

void test02() {
	//func();  // 报错，显示必须要确定T的类型才能使用，尽管现在 没有使用T。
	func<int>();  // 利用显示指定类型的方式，给定T的类型后才可以使用模板。
}

int main()
{
	test02();

	system("pause");
	return 0;
}

总结

• 使用模板时，必须给定出通用数据类型T ，如test01。
• 并且能够推导出一致的类型，如test02。

1.3.3 函数模板案例

案例描述

• 利用函数模板封装一个排序的函数，可以对不同数据类型数据进行排序。
• 排序规则从小到大，排序算法为选择排序。
• 分别利用char数组和int数组进行测试。

实例

#include <iostream>
using namespace std;

// 交换的模板
template<class T>
void mySwap(T &a, T &b) {
	T temp = a;
	a = b;
	b = temp;
}

template<class T>
void mysort(T arr[], int len) {
	for (T i = 0; i < len; i++)
	{
		for (T j = i + 1; j < len; j++)
		{
			T max = i;
			if (arr[max] < arr[j]) {
				mySwap(arr[max], arr[j]);
			}
		}
	}
}

//
template<class T>
void PrintArray(T arr[], int len) {
	for (T i = 0; i < len; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
}

void test01() {
	// 测试int数组
	int intArr[] = { 7,5,8,1,3,9,2,4,6 };
	int num = sizeof(intArr) / sizeof(int);
	mysort(intArr, num);
	PrintArray(intArr, num);
}

void test02() {
	// 测试int数组
	char charArr[] = "bdhnsyg";
	int num = sizeof(charArr) / sizeof(char);
	mysort(charArr, num);
	PrintArray(charArr, num);
}

int main() {
	//test01();
	test02();

	system("pause");
	return 0;
}

总结

• 模板可以提高代码的复用性。

1.3.4 普通函数与函数模板的区别

普通函数与函数模板的区别：

• 普通函数在调用的时候可以发生自动类型转换（隐式类型转换）。
• 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换。
• 如果利用显示指定类型的方式，可以发生隐式类型转换。

示例

#include <iostream>
using namespace std;

//普通函数
int myAdd01(int a, int b)
{
  return a + b;
}

// 函数模板
template<class T>
T myAdd02(T a, T b) {
  return a + b;
}

// 使用函数模板时，如果利用自动类型推导，不会发生自动类型转换，即隐式类型转换
void test01() {
  int a = 10;
  int b = 20;
  char c = 'c';

  cout << myAdd01(a, c) << endl; // 正确，将char类型的c 隐式转换成int；
  //cout << myAdd02(a, c) << endl; // 错误，编译器提示，没有与参数列表匹配的函数模板,myadd02(int，char)
  cout << myAdd02<int>(a, c) << endl;  //正确，如果使用显示指定类型，可以发生隐式类型转换
  cout << myAdd02<char>(a, c) << endl;  //输出是m
}

int main() {
  test01();

  system("pause");
  return 0;
}

总结

• 建议使用显示指定类型的方式，调用函数模板，因为这样可以自己确定通用类型T。

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

调用规则如下：

• 如果函数模板和普通函数都可以实现，优先调用普通函数。
• 可以通过空模板参数列表来**强制调用函数模板**。
• 函数模板也可以发生重载。
• 如果函数模板可以产生更好的匹配，优先调用函数模板。

示例

#include<iostream>
using namespace std;

void myPrint(int a, int b)
{
	cout << "调用的普通函数" << endl;
}

template<class T>
void myPrint(T a, T b) {
	cout << "调用的模板函数" << endl;
}

template<class T>
void myPrint(T a, T b, T c) {
	cout << "调用的重载的模板函数" << endl;
}

void test01() {
	// 1、如果函数模板和普通函数都可以实现，优先调用普通函数
	// 注意：如果告诉编译器 普通函数有，但是只有声明没有实现，或者不在当前文件内实现，就会报错找不到。
	int a = 10;
	int b = 20;
	myPrint(a, b); //函数模板和普通函数都可以实现，优先调用普通函数。

	// 2、可以通过空模板参数列表来强制调用函数模板
	myPrint<>(a, b); // 调用模板函数

	// 3、函数模板也可以发生重载
	int c = 30;
	myPrint(a, b, c);

	// 4、如果函数模板可以产生更好的匹配，优先调用函数模板
	char c1 = 'b';
	char c2 = 'c';
	myPrint(c1, c2);  // 调用函数模板
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结

• 既然提供了函数模板，最好不要再提供普通函数，否则容易出现二义性。

1.3.6 模板的局限性

局限性：

• 模板的通用性并不是万能的。

例如

template<class T>
void f(T a, T b){
	a = b;
}

上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现。

再例如

template<class T>
void f(T a, T b){
	if（a>b）{....} ;
}

• 在上述代码中，如果T的数据类型传入的是像Person这样自定义数据类型，也无法正常运行。
• 因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板。

示例：

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

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

template<class T>
bool myCompare(T &a, T &b) {
	if (a == b) {
		return true;
	}
	else {
		return false;
	}
}

// 具体化  以template<>开头 和 显示具体化的原型 ，并通过名称来指出类型
// 具体化优先于常规模板
template<> bool myCompare(Person &p1, Person &p2) {  // 这里的 template<> 是告诉编译器这个 是 模板的 重载
	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	else {
		return false;
	}
}


void test01() {
	int a = 10;
	int b = 20;
	// 内置数据类型可以直接使用通用的函数模板
	bool ret = myCompare(a, b);
	if (ret) {
		cout << "a = b" << endl;
	}
	else {
		cout << "a ！= b" << endl;
	}
}

void test02() {
	Person p1("Tom", 10);
	Person p2("Tom", 20);
	// 自定义数据类型，不会调用普通的函数模板
	// 可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
	bool ret = myCompare(p1, p2);
	if (ret) {
		cout << "p1 = p2" << endl;
	}
	else {
		cout << "p1 ！= p2" << endl;
	}
}

int main() {

	test01();
	test02();

	system("pause");
	return 0;
}

总结：

• 利用具体化的模板，可以解决自定义类型的通用化
• 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板。

1.4 类模板

1.4.1 类模板语法

类模板作用：

• 建立一个通用类，类中的成员 数据类型可以不具体指定，用一个虚拟的类型来代表。

语法：

template <class T>
类

示例：

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

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 << "  age: " << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

void test01() {
	Person<string,int> p1("孙悟空",999);
	Person<string,int> p2("猪八戒", 999);
	p1.ShowPerson();
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 类模板和函数模板语法类似，在声明模板template后面加类，此类称为类模板。

1.4.2 类模板与函数模板区别

类模板与函数模板区别主要有两点：

• 类模板没有 自动类型推导的使用方式
• 类模板在模板参数列表中可以有默认参数。

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

//类模板
template<class NameType, class AgeType = int>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "name: " << this->m_Name << "  age: " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

void test01() {
	Person<string, int> p1("孙悟空", 1000);  // 类模板使用时候，不可以使用自动类型推导，必须使用显示指定类型的方式，使用类模板。
	p1.showPerson();
}

void test02() {
	Person<string> p2("猪八戒", 999);  // 类模板中的模板参数列表 可以指定默认参数
	p2.showPerson();
}

int main() {

	test02();

	system("pause");
	return 0;
}

总结：

• 类模板 只能 使用显示指定类型 方式。
• 类模板中的模板参数列表中可以有默认参数。

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

类模板中成员函数和普通类中成员函数创建时机是有区别的：

• 普通类中的成员函数一开始就可以创建
• 类模板中的成员函数在调用时才可以创建

示例：

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

class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1 show" << endl;
	}
};

class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 show" << endl;
	}
};

template<class T>
class MyClass
{
public:
	T obj;

	//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时在生成
	void func1() { obj.showPerson1();}
	void func2() { obj.showPerson2();}
};

void test01() {
	MyClass<Person1> p;
	p.func1();
	// 出错的原因，一开始 T obj类型无法确定，只有在创建类模板的时候才能确定他的数据类型，以及他的内部有没有这个函数。
	//p.func2();  // 编译错误，说明函数调用才会去创建成员函数
}

int main() {
	test01();

	system("pause");
	return 0;
}

1.4.4 类模板对象做函数参数

学习目标

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

一共有三种传入方式

• 指定传入的类型： 直接显示对象的数据类型
• 参数模板化： 将对象中的参数变为模板进行传递
• 整个类模板化： 将这个对象类型 模板化进行传递

示例：

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

template<class NameType, class AgeType = int>
class Person
{
public:
	Person(NameType name, AgeType age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	void ShowPerson() {
		cout << "Name: " << this->m_Name << " Age: " << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

// 1、直接指定传入的类型
void printPerson1(Person<string, int> &p) {
	p.ShowPerson();
}

void test01() {
	Person<string> p1("孙悟空",999);
	printPerson1(p1);
}

// 2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2> &p) {
	p.ShowPerson();
	cout << "T1的类型为：" << typeid(T1).name() << endl;
	cout << "T2的类型为：" << typeid(T2).name() << endl;
}

void test02() {
	Person<string, int> p2("猪八戒", 99);
	printPerson1(p2);
}

// 3、整个类模板化
template<class T>
void printPerson3(T &p) {
	cout << "T的类型为：" << typeid(T).name() << endl;
	p.showPerson();
}

void test03() {
	Person<string, int> p3("唐僧", 39);
	printPerson1(p3);
}

int main() {
	test01();
	test02();
	test03();

	system("pause");
	return 0;
}

总结：

• 通过类模板创建的对象，可以有三种方式向函数中进行传参。
• 使用比较广泛的是第一种：指定传入的类型。

1.4.5 类模板与继承

当类模板碰到继承时，需要注意以下几点：

• 当子类继承的父类是一个类模板时，子类在声明的时候，要指出父类中T的类型。
• 如果不指出，编译器无法给子类分配内存。
• 如果想灵活指定出父类中的T的类型，子类也需要变为类模板。

示例：

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

template<class T>
class Base
{
	T m;
};

//class son : public Base{}; //错误，c++编译器需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son: public Base<int>{};

void test01() {
	Son c;
}

// 如果父类是类模板，子类需要指定出父类中的T的数据类型。
// 类模板继承类模板，可以用T2指定父类中的T类型
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:
	Son2() {
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
};

void test02() {
	Son2<int, char> child1;
}

int main() {
	test01();
	test02();

	system("pause");
	return 0;
}

总结：

• 如果父类是类模板，子类需要指定出父类中的T的数据类型。

1.4.6 类模板成员函数类外实现

学习目标：

• 能够掌握类模板中的成员函数类外实现。

示例：

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

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

public:
	T1 m_Name;
	T2 m_Age;
};

// 构造函数 类外实现
template<class T1,class T2>
// 普通的成员函数类外实现是 作用域Person::Person(T1 name,T2 age),
// 但是这里的T1和T2不知道 所以我们要加上 上面的template<class T1,class T2>。
// 此外我们这里实现的是 类模板的 类外实现，我们还需要在作用域上也加T1,T2   Person<T1, T2>::Person(T1 name, T2 age)，告诉编译器这个是类模板
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>::showPerson() {
	cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}

void test01() {
	Person<string, int> p1("Tom", 20);
	p1.showPerson();
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 类模板的成员函数类外实现，需要加上模板的参数列表。

1.4.7 类模板分文件编写

学习目标：

• 掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

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

解决：

• 解决方式1： 直接包含.cpp源文件
• 解决方式2： 将声明和实现写在同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。

示例：

person.hpp中的代码

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

template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	void showPerson();

public:
	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>::showPerson() {
	cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}

类模板分文件编写.cpp中代码

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

// 解决方案 将声明和实现写到一起，文件后缀名改为 .hpp
#include"person.hpp"

void test01() {
	Person<string, int> p("Tom", 30);
	p.showPerson();
}

int main() {
	test01();

	system("pause");
	return 0;
}

1.4.8 类模板和友元

学习目标：

• 掌握类模板配合友元函数的类内和类外实现

全局函数类内实现： 直接在类内声明友元即可

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

示例：

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

// 2、全局函数配合友元 类外实现 
// 2.2 提前让编译器知道Person类模板的存在
template<class T1, class T2>
class Person;

// 2.1.1 最简单的方法就是将这个函数实现写到最前面，让编译器知道这个函数的存在
// 2.1.2 同时这里有一个Person的类模板，需要让编译器提前知道这个类模板的存在
template<class T1, class T2>
void printPerson2(Person<T1, T2> &p) {
   cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
template<class T1, class T2>
class Person
{
   // 1、全局函数配合友元 类内实现
   friend void printPerson1(Person<T1, T2> &p) // 全局函数，类模板做函数参数1 直接指定数据类型
   {
   	cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
   }
   // 2、全局函数配合友元 类外实现
   // 这个友元函数声明是一个普通函数，而下面函数的实现是 一个 模板函数，不一致，所以这里要加一个空模板参数列表
   // 如果全局函数是 类外实现，需要让编译器提前知道这个函数的存在
   friend void printPerson2<>(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;
};

void test01() {
   Person<string, int> p1("Tom", 30);
   printPerson1(p1);
}

void test02() {
   Person<string, int> p2("Jerry", 30);
   printPerson1(p2);
}

int main() {
   test01();
   test02();

   system("pause");
   return 0;
}

总结

• 建议全局函数做类内实现，用法简单，而且编译器直接识别。

2 STL初识

2.1 STL的诞生

• 长久以来，软件界一直希望建立一种可重复利用的东西。
• C++的面向对象和泛型编程思想，目的就是复用性的提升。
• 大多情况下，数据结构和算法都未能有一套标准，导致被迫从事大量重复工作。
• 为了建立数据结构和算法的一套标准，诞生了STL。

2.2 STL基本概念

• STL（Standard Template Library,标准模板库）。
• STL从广义上分为：容器（container）算法（algorithm）迭代器（iterator）。
• 容器和算法之间通过迭代器进行无缝连接。

2.3 STL六大组件

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

• 1、.容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据。
• 2、算法：各种常用的算法，如sort、find、copy、for_each等。
• 3、迭代器：扮演了容器和算法之间的胶合剂。
• 4、仿函数：行为类似函数，可作为算法的某种策略。
• 5、适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。

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

• STL容器：将运用最广泛的一些数据结构实现出来。
• 常用的数据结构：数组、链表、树、栈、队列、集合、映射表 等。
• 这些容器分为 序列式容器 和 关联式容器 两种：
  序列式容器： 强调值的序列，序列式容器中的每个元素均有固定的位置。
  关联式容器： 二叉树结构，各元素之间没有严格的物理上的顺序关系。
  算法： 问题之解决。
• 算法分为： 质变算法 和 非质变算法。
  质变算法： 是指运算过程中会更改区间内的元素的内容。例如 拷贝、替换、删除 等等。
  非质变算法： 是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等。
• 迭代器： 容器和算法之间的粘合剂。
  提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方法。

迭代器种类：

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读、支持++、==、！=
前向迭代器	读写操作、并能向前推进迭代器	读写、支持++、==、！=
双向迭代器	读写操作、并能向前和向后操作	只读、支持++、-
随机访问迭代器	读写操作、可以以跳跃的方式访问任意数据，功能最强的迭代器	读写、支持++、-、[n]、-n、<、<=、>、>=

常用的容器中 迭代器种类为：双向迭代器 和 随机访问迭代器。

2.5 容器算法迭代器初识

STL中最常用的容器是Vector，可以理解为数组，下面我们将学习如何向这个容器中插入数据、并遍历整个容器。

2.5.1 Vector存放内置数据类型

容器：vector
算法： for_each
迭代器：vector::iterator

示例：

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

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);
	v.push_back(50);

	// 每一个容器中都有自己的迭代器，迭代器是用来遍历容器中的元素。
	// v.begin() 返回迭代器，这个迭代器指向容器中的第一个元素。
	// v.end() 返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置。
	// vector<int>::iterator 拿到vector<int>这个容器的迭代器类型。
	vector<int>::iterator pBegin = v.begin();
	vector<int>::iterator pEnd = v.end();

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

	// 第二种遍历方式
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << endl; 
	}



	// 第三种遍历方式
	// 利用STL提供的标准遍历算法，  需要包含头文件 algorithm
	for_each(v.begin(), v.end(),myprint);  //myprint 回调函数，一开始不调用，for_each遍历期间在调用
}

int main() {

	test01();

	system("pause");
	return 0;
}

2.5.2 Vector存放自定义数据类型

示例：

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

// 自定义数据类型
class Person {
public:
	Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
public:
	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);

	// vector<Person>::iterator 中<>是什么类型，*it就是什么类型，
	// 其中，it可以看成是一个指针
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
		// *it是Person类型，Person.name获取name的属性。
		cout << "姓名：" << (*it).m_Name << "年龄为：" << (*it).m_Age << endl;
		
	}
}

// 存放对象指针
void test02() {
	vector<Person*> v;  // 即 vector中存放的是自定义数据类型的地址。

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

	// vector中存放的是自定义数据类型的地址，所以应该 使用 引用的方式 存入数据的地址。
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);

	// vector<Person *>::iterator 中<>是什么类型，*it就是什么类型，
	// 即 *it 是Person类型的指针，通过 -> 导出属性
	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) {
		Person * p = (*it);
		cout << "姓名：" << p->m_Name << "年龄为：" << p->m_Age << endl;
	}
}

int main() {
	test01();
	test02();

	system("pause");
	return 0;
}

2.5.3 Vector容器嵌套容器

容器中嵌套容器，将所有数据进行遍历输出。

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

void test01() {
	
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	vector<int> v4;
	vector<int> v5;

	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);
		v5.push_back(i+5);
	}

	vector<vector<int>> v;
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	v.push_back(v5);

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

int main() {

	test01();

	system("pause");
	return 0;
}

3 STL-常用容器

3.1 string容器

3.1.1 string基本概念

本质：

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

string和char*的区别：

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

特点：

• string内部封装了很多成员方法。
• 例如： 查找find，拷贝copy，删除delete，替换replace，插入insert。
• string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责。

3.1.2 string构造函数

构造函数原型：

• string()；//创建一个空的字符串，例如 string str；
  string(const char* s); // 使用字符串s 初始化；
• string(const string& str); // 使用一个string对象初始化另外一个string对象；
• string(int n,char c); // 使用n个字符c初始化。

示例：

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

void test01() {
	string s1; //创建空字符串，调用无参构造函数
	cout << "s1 = " << s1 << endl;

	const char* str = "hello world";
	string s2(str);  // 把c类型的字符串转换成 string
	cout << "s2 = " << s2 << endl;

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

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



}

int main() {

	test01();

	system("pause");
	return 0;
}

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

#include<iostream>
using namespace std;
#include<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 world");
	cout << "str4 = " << str4 << endl;

	string str5;
	str5.assign("hello world",4);
	cout << "str5 = " << str5 << endl;

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

	string str7;
	str7.assign(5,'x');
	cout << "str7 = " << str7 << endl;

}

int main() {
	test01();

	system("pause");
	return 0;
}

3.1.4 string 字符串拼接

功能描述：

• 实现在字符串末尾拼接字符串

函数原型：

• string& operator+=（const char* str）； // 重载+=操作符
• string& operator+=（const char c）； // 重载+=操作符
• string& operator+=（const string& str）； // 重载+=操作符
• string& append（const char* s）； // 把字符串s连接到当前字符串结尾
• string& append（const char* s，int n）； // 把字符串s的 前n个字符串 连接到当前字符串结尾。
• string& append（const string& s）； // 同operator+=（const string& str）；
• string& append（const string &s，int pos， int n）； // 把字符串s从pos开始的n个字符连接到字符串结尾。

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

void test01() {
	string str1 = "我";
	str1 += " 爱玩游戏";
	cout << "str1 = " << str1 << endl;

	str1 += ":";
	cout << "str1 = " << str1 << endl;

	string str2 = " LOL DNF" ;
	str1 += str2;   // str1的后面加上str2
	cout << "str1 = " << str1 << endl;

	string str3 = "I";
	str3.append(" love");
	str3.append(" game abcded", 4);
	str3.append(str2, 4, 4);//从下标4位置开始，截取4个字符，拼接到字符串末尾
	cout << "str3 = " << str3 << endl;



}

int main() {
	test01();

	system("pause");
	return 0;
}

3.5.1 string 查找和替换

功能描述：

• 查找： 查找指定字符串是否存在。
• 替换： 在指定的位置替换字符串。

函数原型：

• int find（const string& str，int pos = 0）const；//查找str第一次出现位置，从pos开始查找。
• int find（const char* s，int pos = 0）const；//查找s第一次出现位置，从pos开始查找。
• int find（const char c，int pos，int n）const；//从pos 位置开始，查找字符串的前n个字符，返回字符串s第一次出现的位置。
• int rfind（const string& str，int pos = npos）const； // 查找str最后一次出现的位置，从pos开始查找。
• int rfind（const char* ，int pos = npos）const； // 查找str最后一次出现的位置，从pos开始查找。
• int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置。
• int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
• string& replace(int pos, int n, const string& str); //从pos位置开始，将字符串的n个字符替换成字符串str。
• string& replace(int pos, int n,const char* s); //从pos位置开始，将字符串的n个字符替换成字符串s。

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

void test01() {

	//查找
	string str1 = "abcdefgde";
	int pos = str1.find("de");
	if (pos == -1) {
		cout << "未找到！" << endl;
	}
	else {
		cout << "pos = " << pos << endl;  //de第一次出现的位置是3，pos返回3
	}
}

void test02() {
	// 替换
	string str1 = "abcdefgde";
	str1.replace(1, 3, "1111"); //从第一个位置开始，到第三个位置的字符bcd替换成1111，
	cout << "str1 = " << str1 << endl;
}

int main() {
	test01();
	test02();

	system("pause");
	return 0;
}

总结：

• find查找是从左往右，rfind是从右往左
• find 找到字符串后，返回第一个字符位置，找不到返回-1。
• replace在替换时，要指定从那个位置开始，多少个字符，替换成什么样的字符串。

3.1.6 string字符串比较

功能描述：

• 字符串之间的比较。

比较方式：

• 字符串比较是按照字符的ASCII码进行比较。
• = 返回 0
• ＞返回 1
• < 返回 -1

函数原型：

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

示例：

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

void test01() {
	string s1 = "hello";
	string s2 = "ahello";

	int ret = s1.compare(s2);
	if (ret == 0) {
		cout << "s1 = s2" << endl;
	}
	else if(ret == -1) {
		cout << "s1 < s2" << endl;  
	}
	else {
		cout << "s1 > s2" << endl;
	}
}

int main() {
	test01();

	system("pause");
	return 0;
}

3.1.7 string 字符存取

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

• char& operator[](int n); // 通过[]方式取字符
• char& at（int n）； //通过at方法获取字符

示例：

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

void test01() {
	string str = "hello world";
	for (int i = 0; i < str.size(); i++) {
		cout << str[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < str.size(); i++) {
		cout << str.at(i)<< " ";
	}
	cout << endl;

	// 字符修改
	str[0] = 'x';
	str.at(1) = 'x';
	cout << "str = " << str << endl;

}

int main() {

	test01();

	system("pause");
	return 0;
}

3.1.8 string 插入和删除

功能描述：

• 对string字符串进行插入和删除字符操作。

函数原型：

• string& insert(int pos, const char* s); //插入字符串
• string& insert(int pos, const string& str); //插入字符串
• string& insert(int pos, int n, char c); //在指定位置插入n个字符c
• string& erase(int pos, int n = npos); //删除从Pos开始的n个字符

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

void test01() {
	string str1 = "hello";  
	str1.insert(1, "11");  // 在pos位置插入字符串
	cout << "str1 = " << str1 << endl;

	str1.insert(1, 3, 'a');  // 在pos位置插入n个字符
	cout << "str1 = " << str1 << endl; 

	str1.erase(1, 2);  // 删除从1开始的两个字符
	cout << "str1 = " << str1 << endl;


}

int main() {
	test01();

	system("pause");
	return 0;
}

总结： 插入和删除的起始下标都是从0开始。

3.1.9 string字符串

功能描述：

• 从字符串中获取想要的字符串

函数原型：

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

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

void test01() {
	string str1 = "abcdefg";
	string substr = str1.substr(1, 3);  //获取指定取件的字符
	cout << "substr = " << substr << endl;

	string email = "hello@sina.com";
	int pos = email.find("@");
	string username = email.substr(0, pos);
	cout << "username = " << username << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

3.2 vector容器

3.2.1 vector基本概念

功能：

• vector数据结构和数组非常相似，也称为单端数组；

vector与普通数组的区别：

• 不同之处就在于数组是静态空间，而vector可以动态扩展。

vector动态扩展：

• 并不是在原有空间之后续接新空间，而是寻找更大的内存空间，将原数据拷贝到新空间后，释放原空间。
• vector容器的迭代器是支持随机访问的迭代器。
  

3.2.2 vector构造函数

功能描述：

• 创建vector容器

函数原型：

• vector v; //采用模板实现类实现，默认构造函数
• vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
• vector(n, elem); //构造函数将n个elem拷贝给本身。
• vector(const vector &vec); //拷贝构造函数。

示例：

#include<iostream>
using namespace std;
#include<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> v; //无参构造
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	printVector(v);

	vector<int> v2(v.begin(), v.end()); // 将区间内的元素拷贝给本身
	printVector(v2);

	vector<int> v3(10,100);  // 构造函数将n个elem拷贝给本身
	printVector(v3);

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

int main() {
	test01();

	system("pause");
	return 0;
}

3.2.3 vector赋值操作

功能描述：

• 给vector容器赋值

函数原型：

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

#include<iostream>
using namespace std;
#include<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> v; //无参构造
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	printVector(v);

	vector<int> v2;
	v2 = v; // 等号重载
	printVector(v2);

	vector<int> v3;
	v3.assign(v.begin(), v.end()); // 将区间内的元素拷贝给本身
	printVector(v3);

	vector<int> v4;
	v4.assign(10, 100);  // 构造函数将n个elem拷贝给本身
	printVector(v4);
}

int main() {
	test01();

	system("pause");
	return 0;
}

3.2.4 vector 容量与大小

功能描述：

• 对vector容器的容量和大小进行操作。

函数原型：

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

#include<iostream>
using namespace std;
#include<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> v; //无参构造
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	printVector(v);

	if (v.empty())
	{
		cout << "v为空！" << endl;
	}
	else {
		cout << "v不为空！" << endl;
		cout << "v的容量为：" << v.capacity() << endl;
		cout<< "v的大小为：" << v.size() << endl;
	}

	// resize重新指定大小，若指定的更大，默认用0填充新位置，可以利用重载版本更改默认填充
	v.resize(15, 10);
	printVector(v);

	// resize重新指定大小，若指定的更小，超过的部分被删除。
	v.resize(5);
	printVector(v);
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 判断是否为空：empty
• 返回元素个数：size
• 返回容器容量：capacity
• 重新指定大小：resize

3.2.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(); //删除容器中所有元素

#include<iostream>
using namespace std;
#include<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> v; //无参构造
	for (int i = 0; i < 10; i++) {
		// 尾插
		v.push_back(i);
	}
	printVector(v);

	// 尾删
	v.pop_back();
	printVector(v);

	// 插入
	v.insert(v.begin(), 100);
	printVector(v);

	v.insert(v.begin(),2, 10);
	printVector(v);

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

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

}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 尾插： push_back
• 尾删： pop_back
• 插入： insert（通过位置迭代器）
• 删除： erase（通过位置迭代器）
• 清空：clear

3.2.6 vector数据存取

功能描述：

• 对vector中的数据进行存取。

函数原型：

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

示例：

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


void test01() {
	vector<int> v; //无参构造
	for (int i = 0; i < 10; i++) {
		// 尾插
		v.push_back(i);
	}
	for (int i = 0; i < v.size(); i++) {
		cout << v[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < v.size(); i++) {
		cout << v.at(i) << " ";
	}
	cout << endl;

	cout << "v的第一个元素为："<<v.front()<<endl;
	cout << "v的最后一个元素为：" << v.back() << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 除了用迭代器获取vector容器中的元素，[ ]和at也可以。
• front返回容器第一个元素。
• back返回容器最后一个元素。

3.2.7 vector互换容器

功能描述：

• 实现两个容器内元素互换。

函数原型：

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

示例：

#include<iostream>
using namespace std;
#include<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> v; //无参构造
	for (int i = 0; i < 10; i++) {
		// 尾插
		v.push_back(i);
	}
	printVector(v);

	vector<int> v2; //无参构造
	for (int i = 10; i > 0; i--) {
		// 尾插
		v2.push_back(i);
	}
	printVector(v2);

	// 互换容器
	cout << "互换后" << endl;
	v.swap(v2);
	printVector(v);
	printVector(v2);
}

void test02() {
	vector<int> v; //无参构造
	for (int i = 0; i < 10000; i++) {
		// 尾插
		v.push_back(i);
	}
	//printVector(v);
	cout << "v的容量为： " << v.capacity() << endl;
	cout << "v的大小为： " << v.size() << endl;

	v.resize(3); //重新指定大小
	// 虽然现在重新指定大小后只有3个，但是之前分配的容量没有改变，还和上面的一样。
	cout << "v的容量为： " << v.capacity() << endl;
	cout << "v的大小为： " << v.size() << endl;

	// 收缩内存
	// Vector<int>(v)：匿名对象，调用拷贝构造函数，利用v创建了一个新的对象
	vector<int>(v).swap(v);
	cout << "v的容量为： " << v.capacity() << endl;
	cout << "v的大小为： " << v.size() << endl;
}

int main() {
	test01();
	test02();

	system("pause");
	return 0;
}

总结：

• swap可以使两个容器互换，可以达到收缩内存的效果。

3.2.8 vector预留空间

功能描述:

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

函数原型：

• reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。（只是单纯的留下这一块内存，并没有给这块数据初始化）

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


void test01() {
	vector<int> v; //无参构造
	
	// 预留空间
	v.reserve(100000);

	int num = 0;
	int *p = NULL;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
		if (p != &v[0]) {  // vector如果内存不够，会重新分配内存，这里看分配了多少次
			// 即 如果p的地址不等于vector的首地址，就让他们强制相等，从而判断到底分配了多少次内存
			p = &v[0]; 
			num++;
		}
	}
	cout << "num = " << num << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 如果数据量比较大，可以一开始利用reserve预留空间。

3.3 deque容器

3.3.1 deque容器的基本概念

功能：

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

deque和vector区别：

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

deque内部工作原理：

• deque内部有个中控器，维护每段缓冲区内容，缓冲区中存放真实数据。
• 中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间。
• deque容器的迭代器也是支持随机访问的。
  

3.3.2 deque构造函数

功能描述：

• deque容器构造

函数原型：

• deque deqT; //默认构造形式
• deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
• deque(n, elem); //构造函数将n个elem拷贝给本身。
• deque(const deque &deq); //拷贝构造函数

示例：

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

void printDeque(deque<int>& d) {
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		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); // 构造函数将n个元素拷贝给本身。
	printDeque(d3);

	deque<int>d4 = d3; 
	printDeque(d4);
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• deque和vector容器的构造方式几乎一致。

3.3.3 deque赋值

功能描述：

• deque容器进行赋值

函数原型：

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

示例：

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

void printDeque(deque<int>& d) {
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		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;
	d2 = d1;
	printDeque(d2);

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

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

}

int main() {
	test01();

	system("pause");
	return 0;
}

3.3.4 deque大小操作

功能描述：

• deque容器大小进行操作

函数原型：

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

示例：

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

void printDeque(deque<int>& d) {
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		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;
	}
	// 重新指定大小
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(25);
	printDeque(d1);

}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• deque没有容量的概念
• 判断容器是否为空：empty
• 返回元素个数： size
• 重新指定个数：resize

3.3.5 deque插入和删除

功能描述：

• deque容器中插入和删除数据

函数原型：

两端插入操作：

• push_back(elem); //在容器尾部添加一个数据
• push_front(elem); //在容器头部插入一个数据
• pop_back(); //删除容器最后一个数据
• pop_front(); //删除容器第一个数据

指定位置操作：

• insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
• insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值。
• insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值。
• clear(); //清空容器的所有数据
• erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
• erase(pos); //删除pos位置的数据，返回下一个数据的位置。

示例：

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

void printDeque(deque<int>& d) {
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		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;
	}
	// 重新指定大小
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(25);
	printDeque(d1);
}
int main() {
	test01();

	system("pause");
	return 0;
}

3.3.6 deque数据存取

功能描述：

• deque容器中数据的存取操作。

函数原型：

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

示例：

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

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

void test01() {
	deque<int> d1; //无参构造函数
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(10);
	d1.push_front(20);

	for (int i = 0; i < d1.size(); i++) {
		cout << d1[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < d1.size(); i++) {
		cout << d1.at(i) << " ";
	}
	cout << endl;

	cout << "front: " << d1.front() << endl;
	cout << "back: " << d1.back() << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 除了用迭代器获取deque容器中的元素，[ ]和at也可以。
• front返回容器第一个元素
• back返回容器的最后一个元素

3.3.6 deque排序

功能描述：

• 利用算法实现对deque容器进行排序。

算法：

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

示例：

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

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

void test01() {
	deque<int> d1; //无参构造函数
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(10);
	d1.push_front(20);

	printDeque(d1);
	sort(d1.begin(), d1.end());
	printDeque(d1);

}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• sort算法非常使用，使用时只需要包含头文件algorithm即可。

3.4 案例-评委打分

3.4.1 案例描述

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

3.4.2 实现步骤

• 1、创建五名选手，放到vector中
• 2、遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
• 3、sort算法对deque容器中分数排序，去除最高和最低分
• 4、deque容器遍历一遍，累加总分
• 5、获取平均分

示例：

#include<iostream>
using namespace std;
#include<deque>
#include<algorithm>
#include<string>
#include<vector>
#include<time.h>

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

public:
	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;//0-40的随机数+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 << " ";  //dit 相当于一个指针，<>中的类型是什么，*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 showPerson(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);

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

	// 3、给5名选手打分
	setScore(v);

	// 4、显示最后得分
	showPerson(v);

	system("pause");
	return 0;
}

总结：

• 选取不同的容器操作数据，可以提升代码的效率。

3.5 stack容器

3.5.1 stack基本概念

概念：

• stack是一种先进后出(Frist In Last Out,FILO)的数据结构，它只有一个出口栈中的顶端的元素才可以被外界使用，因此栈不允许有便利行为。
• 栈中进入数据称为：入栈 push
• 栈中弹出数据称为：出栈 pop

3.5.2 stack 常用接口

功能描述：

• 栈容器常用的对外接口

构造函数：

• stackstk; //stack采用模板类实现， stack对象的默认构造形式
• stack(const stack &stk); //拷贝构造函数

赋值操作：

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

数据存取：

• push(elem); //向栈顶添加元素
• pop(); //从栈顶移除第一个元素
• top(); //返回栈顶元素

大小操作：

• empty(); //判断堆栈是否为空
• size(); //返回栈的大小

示例：

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

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

void test01() {
	stack<int> s; //无参构造函数

	// 向栈中添加元素，叫做 压栈 入栈
	s.push(10);
	s.push(20);
	s.push(30);

	while (!s.empty()) {
		// 输出栈顶元素
		cout << "栈顶元素为：" << s.top() << endl;
		// 弹出栈顶元素
		s.pop();
	}
	cout << "栈的大小为：" << s.size() << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 入栈：push
• 出栈：pop
• 返回栈顶：top
• 判断栈是否为空：empty
• 返回栈大小：size

3.6 queue容器

3.6.1 queue基本概念

概念：

• Queue是一种先进先出（Frist In Frist Out，FIFO）的数据结构，他有两个出口。
• 队列容器允许从一端新增元素，从另一段移除元素。
• 队列中只有对头和队尾才可以被外界使用，因此队列不允许有遍历行为。
• 队列中进数据称为：入队 push
• 队列中出数据称为：出队 pop

3.6.2 queue常用接口

功能描述：

• 栈容器常用的对外接口

构造函数：

• queue que; //queue采用模板类实现，queue对象的默认构造形式
• queue(const queue &que); //拷贝构造函数

赋值操作：

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

数据存取：

• push(elem); //往队尾添加元素
• pop(); //从队头移除第一个元素
• back(); //返回最后一个元素
• front(); //返回第一个元素

大小操作：

• empty(); //判断堆栈是否为空
• size(); //返回栈的大小

#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;
	}
public:
	string m_Name;
	int m_Age;
};

void test01() {
	queue<Person> q;
	
	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 30);
	Person p3("猪八戒", 900);
	Person p4("沙僧",800);

	//向队列中添加数据 入队操作
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	//队列不提供迭代器，更不支持随机访问
	while (!q.empty()) {
		// 输出队头元素
		cout << "队头元素： 姓名：" << q.front().m_Name
			<< "年龄：" << q.front().m_Age << endl;
		cout << "队尾元素： 姓名：" << q.back().m_Name
			<< "年龄：" << q.back().m_Age << endl;
		cout << endl;
		// 弹出队头元素
		q.pop();
	}
	cout << "队列大小为：" << q.size() << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 入队：push
• 出队：pop
• 返回队头元素：front
• 返回队尾元素：back
• 判断队是否为空：empty
• 返回队列大小：size

3.7 list容器

3.7.1 list基本概念

功能：

• 将数据进行链式存储
• 链表（list）： 是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。
• 节点的组成：一个是存储数据元素的数据域，另外一个是存储下一个节点地址的指针域。
• STL中的链表是一个双向循环链表。
• 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。
• 
  
  

list的优点：

• 采用动态存储分配，不会造成内存浪费和溢出
• 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

• 链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大。
  

List一个重要的性质：

• 插入和删除操作都不会造成原有list迭代器的失效，这在vector中是不成立的

总结：

• STL中List和vector是两个最常用的容器，各有优缺点。

3.7.2 list构造函数

功能描述：

• 创建list容器

函数原型：

• list lst; //list采用采用模板类实现,对象的默认构造形式：
• list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身
• list(n,elem); //构造函数将n个elem拷贝给本身。
• list(const list &lst); //拷贝构造函数。

示例：

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

void printList(list<int>& l) {
	for (list<int>::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.push_back(50);

	printList(l1);

	list<int>l2(l1.begin(), l1.end());
	printList(l1);

	list<int>l3(l2);
	printList(l3);

	list<int>l4(10,100);
	printList(l4);
}

int main() {
	test01();

	system("pause");
	return 0;
}

3.7.3 list赋值和交换

功能描述：

• 给list容器赋值，以及交换list容器

函数原型：

• assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
• assign(n, elem); //将n个elem拷贝赋值给本身。
• list& operator=(const list &lst); //重载等号操作符
• swap(lst); //将lst与本身的元素互换。

示例：

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

void printList(list<int>& l) {
	for (list<int>::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.push_back(50);

	printList(l1);

	// 赋值
	list<int>l2;
	l2 = l1;
	printList(l2);

	list<int>l3;
	l3.assign(l1.begin(),l1.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);
	l1.push_back(50);

	list<int>l2;
	l2.assign(10, 100);
	
	cout << "交换前：" << endl;
	printList(l1);
	printList(l2);

	cout << "交换后：" << endl;
	l1.swap(l2);
	printList(l1);
	printList(l2);

}

int main() {
	//test01();
	test02();

	system("pause");
	return 0;
}

3.7.4 list大小操作

功能描述：

• 对list容器的大小进行操作。

函数原型：

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

示例：

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

void printList(list<int>& l) {
	for (list<int>::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.push_back(50);

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

	system("pause");
	return 0;
}

总结：

• 判断是否为空：empty
• 返回元素的个数：size
• 重新指定个数：resize

3.7.5 list插入和删除

功能描述：

• 对list容器的数据进行插入和删除。

函数原型：

• push_back(elem);//在容器尾部加入一个元素
• pop_back();//删除容器中最后一个元素
• push_front(elem);//在容器开头插入一个元素
• pop_front();//从容器开头移除第一个元素
• insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
• insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
• insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
• clear();//移除容器的所有数据
• erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
• erase(pos);//删除pos位置的数据，返回下一个数据的位置。
• remove(elem);//删除容器中所有与elem值匹配的元素。

示例：

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

void printList(list<int>& l) {
	for (list<int>::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_front(100);
	l1.push_front(200);
	l1.push_front(300);

	printList(l1);

	// 尾删
	l1.pop_back();
	printList(l1);

	// 头删
	l1.pop_front();
	printList(l1);

	// 插入
	list<int>::iterator it = l1.begin();
	l1.insert(++it, 1000);
	printList(l1);

	// 删除
	it = l1.begin();
	l1.erase(++it);
	printList(l1);

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

	// 清空
	l1.clear();
	printList(l1);
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 尾插：push_back
• 尾删：pop_back
• 头插：push_front
• 头删：pop_front
• 插入：insert
• 删除：erase
• 移除：remove
• 清空：clear

3.7.6 list数据存取

功能描述：

• 对list容器的数据进行存取操作。

函数原型：

• front(); //返回第一个元素。
• back(); //返回最后一个元素。

示例：

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

void printList(list<int>& l) {
	for (list<int>::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_front(100);
	l1.push_front(200);
	l1.push_front(300);

	//cout << l1.at(0) << endl; // 错误，不支持at访问数据
	//cout << l1[0] << endl;  // 错误，不支持[ ]访问数据
	// 原因：list链表不是用连续的线性空间存储，所以迭代器不支持随机访问
	cout << " 第一个元素为： "<<l1.front() << endl;
	cout << " 最后一个元素为： " << l1.back() << endl;

	// list容器的迭代器是双向迭代器，不支持随机访问
	list<int>::iterator it = l1.begin();
	//it = it + 1; // 错误，不可以跳跃访问（it = it + n），即使是it = it + 1
	// 只支持 ++ --
	it++;
	it--;

}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• list容器中不可以通过【】和at方式访问数据
• 返回第一个元素：front
• 返回最后一个元素：back

3.7.7 list反转和排序

功能描述：

• 将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

• reverse(); //反转链表
• sort(); //链表排序

示例：

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

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

bool compare(int val1, int val2) {
	// 降序，就是让第一个 > 第二个
	return val1 > val2;  
}

void test01() {
	list<int>l1;
	//尾插
	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	// 头插
	l1.push_front(100);
	l1.push_front(200);
	l1.push_front(300);

	printList(l1);

	// 反转容器中的元素
	l1.reverse();  // 默认的排序规则  从小到大
	printList(l1);

	l1.sort(compare);  // 指定规则，从大到小
	printList(l1);
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 反转：reverse
• 排序：sort

3.7.8 排序案例

案例描述：

将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高

排序规则：

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

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

class Person {
public:
	Person(string name, int age, int height ) {
		this->m_Name = name;
		this->m_Height = height;
		this->m_Age = age;
	}
public:
	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_Age > p2.m_Height;
	}
	else {
		return p1.m_Age > p2.m_Age;
	}
}

void test01() {
	Person p1("刘备", 35, 175);
	Person p2("曹操", 45, 185);
	Person p3("孙权", 40, 170);
	Person p4("赵云", 25, 190);
	Person p5("张飞", 35, 160);
	Person p6("关羽", 35, 200);

	list<Person> L1;
	L1.push_back(p1);
	L1.push_back(p2);
	L1.push_back(p3);
	L1.push_back(p4);
	L1.push_back(p5);
	L1.push_back(p6);

	for (list<Person>::iterator pit = L1.begin(); pit != L1.end(); pit++) {
		cout << " 姓名：" << (*pit).m_Name << " 年龄：" << pit->m_Age << " 身高：" << pit->m_Height <<endl;
	}
	cout << endl;

	cout << "-----------------------------" << endl;
	L1.sort(comparePerson); // 排序

	for (list<Person>::iterator pit = L1.begin(); pit != L1.end(); pit++) {
		cout << "姓名：" << (*pit).m_Name << " 年龄：" << pit->m_Age << " 身高：" << pit->m_Height << endl;
	}
	cout << endl;

}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序。
• 高级排序只是在排序规则上在进行一次逻辑规则指定，并不复杂。

3.8 set/multiset容器

3.8.1 set基本概念：

简介：

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

本质：

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

set和multiset区别：

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

3.8.2 set构造和赋值

功能描述：

• 创建set容器以及赋值

构造：

• set st; //默认构造函数：
• set(const set &st); //拷贝构造函数

赋值：

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

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

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

void test01() {
	set<int>l1;
	l1.insert(10);
	l1.insert(20);
	l1.insert(30);
	l1.insert(40);
	l1.insert(50);

	printList(l1);

	// 拷贝构造
	set<int>s2(l1);
	printList(s2);

	// 赋值
	set<int>s3;
	s3 = s2;
	printList(s3);
	
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• set容器插入数据时用insert
• set容器插入数据时数据会自动排序

3.8.3 set大小和交换

功能描述：

• 统计set容器大小以及交换set容器

函数描述：

• size(); //返回容器中元素的数目
• empty(); //判断容器是否为空
• swap(st); //交换两个集合容器

示例：

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

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

void test01() {
	set<int>s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);
	s1.insert(50);

	printList(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(20);
	s1.insert(30);
	s1.insert(40);
	s1.insert(50);

	set<int> s2;
	s2.insert(100);
	s2.insert(200);
	s2.insert(300);
	s2.insert(400);
	s2.insert(500);

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

	cout << "交换后" << endl;
	s1.swap(s2);
	printList(s1);
	printList(s2);
	cout << endl;

}

int main() {
	//test01();
	test02();

	system("pause");
	return 0;
}

总结

• 统计大小：size
• 判断是否为空：empty
• 交换容器：swap

3.8.4 set插入和删除

功能描述：

• 统计set容器进行插入数据和删除数据

函数描述：

• insert(elem); //在容器中插入元素。
• clear(); //清除所有元素
• erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
• erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
• erase(elem); //删除容器中值为elem的元素。

示例：

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

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

void test01() {
	set<int>s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);
	s1.insert(50);

	printList(s1);

	// 删除
	s1.erase(s1.begin());
	printList(s1);
	s1.erase(30);
	printList(s1);
	//清空
	//s1.erase(s1.begin(), s1.end());
	s1.clear();
	printList(s1);
}

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

3.8.5 set查找和统计

功能描述：

• 统计set容器进行查找数据以及统计数据

函数描述：

• find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
• count(key); //统计key的元素个数

示例：

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

void test01() {
	set<int>s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);
	s1.insert(50);

	// 查找
	set<int>::iterator pos = s1.find(30);
	if (pos != s1.end()) {
		cout << "找到了元素：" << *pos << endl;
	}
	else {
		cout << "未找到元素" << endl;
	}
	//统计
	int num = s1.count(30);
	cout << "num = " << num << endl;

}


int main() {
	test01();


	system("pause");
	return 0;
}

总结：

• 查找：find（返回的是迭代器）
• 统计：count（对于set，结果为0或者1）

3.8.6 set和multiset区别

功能描述：

• 掌握set和multiset的区别

区别：

• set不可以插入重复的数据，而multiset可以
• set插入数据的同时会返回插入结果，表示插入是否成功
• multiset不会检测数据，因此可以插入重复数据。

示例：

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


// set和multiset区别
void test01() {
	set<int> s;
	// 在向set中插入数据的时候，会返回一个pair对组，对组中有两个值，一个是迭代器，另外一个表示是否插入成功
	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
	multiset<int> ms;
	ms.insert(10);
	ms.insert(10);

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

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 如果说不允许插入重复数据可以利用set
• 如果需要插入重复数据利用multiset

3.8.7 pair对组创建

功能描述：

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

两种创建方式：

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

示例：

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

void test01() {
	pair<string, int>p(string("Tom"), 20);
	cout << "姓名：" << p.first << " 年龄:" << p.second << endl;

	pair<string, int>p2 = make_pair(string("Jerry"), 20);
	cout << "姓名：" << p2.first << " 年龄:" << p2.second << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

3.8.8 set容器排序

功能描述：

• set容器默认排序规则是从小到大，掌握如何改变排序规则

主要技术点：

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

示例一：set存放内置数据类型：

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

class Mycompare {
public:
	bool operator()(int val1, int val2) {
		return val1 > val2;
	}
};

void test01() {
	set<int> s1;
	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(50);
	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(50);
	s2.insert(20);
	s2.insert(30);
	for (set<int>::iterator it = s2.begin(); it != s2.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 利用仿函数可以指定set容器的排序规则

示例二：set存放自定义数据类型：

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

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

};

class MycomparePerson {
public:
	bool operator()(const Person& p1,const Person& p2) {
		// 按照年龄进行排序 降序
		return p1.m_Age > p2.m_Age;
	}
};

void test01() {
	set<Person,MycomparePerson> s;
	
	Person p1("刘备", 23);
	Person p2("关羽", 27);
	Person p3("张飞", 25);
	Person p4("赵云", 31);

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

	for (set<Person, MycomparePerson>::iterator it = s.begin(); it != s.end(); it++) {
		cout <<"姓名："<< (*it).m_Name << " 年龄："<<it->m_Age << endl;
	}
	cout << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 对于自定义数据类型，set必须指定排序规则后才可以插入数据

3.9 map/multimap容器

3.9.1map基本概念：

简介：

• map中所有的元素都是pair
• pair的第一个元素为key（键值），起到索引作用，第二个值是value（实值）
• 所有元素都会根据元素的键值自动排序

本质：

• map/multimap属于关联式容器，地层结构是用二叉树实现。

优点：

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

map和multimap区别：

• map中不允许有重复的key值元素
• multimap允许有重复的key值元素

3.9.2map构造和赋值：

功能描述：

• 对map容器进行构造和赋值操作

函数原型：

构造：

• map<T1, T2> mp; //map默认构造函数:
• map(const map &mp); //拷贝构造函数

赋值：

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

示例：

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

	printMap(m);

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

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

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• map中所有元素都是成对出现，插入数据时候要使用对组

3.9.3 map大小和交换：

功能描述：

• 统计map容器大小以及交换map容器

函数原型：

• size(); //返回容器中元素的数目
• empty(); //判断容器是否为空
• swap(st); //交换两个集合容器

示例：

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

	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;
	m.swap(m2);
	printMap(m);
	printMap(m2);
}

int main() {
	test02();

	system("pause");
	return 0;
}

总结

• 统计大小：size
• 判断是否为空：empty
• 交换容器：swap

3.9.4 map插入和删除：

功能描述：

• map容器进行插入数据和删除数据

函数原型：

• insert(elem); //在容器中插入元素。
• clear(); //清除所有元素
• erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
• erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
• erase(key); //删除容器中值为key的元素。

示例：

#include<iostream>
using namespace std;
#include<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;
	printMap(m);

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

	m.erase(3);
	printMap(m);

	// qingkon
	m.clear();
	// m.erase(m.begin()mm.end());
	printMap(m);
	
}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• map的插入方式很多，记住其一即可
• 插入：insert
• 删除：erase
• 清空：clear

3.9.5 map查找和统计：

功能描述：

• map容器进行查找数据以及统计数据

函数原型：

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

示例：

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

	// 统计
	int num = m.count(3);
	cout << "num = " << num << endl;
	

}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 查找：find
• 统计：count（对于map，结果为0或1）

3.9.6 map容器排序：

学习目标：

• map容器默认排序规则为：从小到大排序，掌握如何改变排序规则

主要技术点：

• 利用仿函数，可以改变排序规则*;

示例：

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

class MyCompare{
public:
	bool operator()(int v1, int v2){
		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(pair<int, int>(4, 40));
	m.insert(pair<int, int>(5, 50));

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

}

int main() {
	test01();

	system("pause");
	return 0;
}

总结：

• 利用仿函数可以指定map容器的排序规则
• 对于自定义数据类型，map必须要指定排序规则，同set容器

3.10 案例-员工分组

3.10.1 案例描述

• 公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
• 员工信息有: 姓名 工资组成；部门分为：策划、美术、研发
• 随机给10名员工分配部门和工资
• 通过multimap进行信息的插入 key(部门编号) value(员工)
• 分部门显示员工信息

3.10.2 实现步骤

• 1、创建10名员工，放到vector中
• 2、遍历vector容器，取出每个员工，进行随机分组
• 3、分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中
• 分部门显示员工信息

案例代码：

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

#define CEHUA  0
#define MEISHU 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
		// 将员工放到vector中
		v.push_back(worker);
	}
}

// 员工分组
void serGroup(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

		// 将员工插入到分组中
		// key是部门编号 value是具体员工
		m.insert(pair<int, Worker>(deptId, *it));
	}
}

// 显示员工分组
void showWorkerByGroup(multimap<int, Worker>& m) {
	// 0 A B C 1 D E 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(MEISHU);
	count = m.count(MEISHU);
	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;
	serGroup(vWorker, mWorker);

	// 3 显示员工分组
	showWorkerByGroup(mWorker);

	system("pause");
	return 0;
}

标签：容器,cout,int,提高,编程,C++,push,include,模板
来源： https://blog.csdn.net/weixin_46263207/article/details/122676297