STL常用容器-C++

1. String 容器

1.1 string 基本概念

本质：

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

string 和 char* 区别：

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

特点：

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

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

//string 的构造函数
int main() {
	string s1;//默认构造
	
	const char* str = "hello";
	string s2(str);

	string s3(s2);

	string s4(5, 'c');

	return 0;
}

总结：string 的多种构造方式没有可比性，灵活使用即可。

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

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

//string 的赋值操作
int main() {
	string s1,s2;
	s1 = "hello";//1
	s2 = s1;//2
	s1 = 'c';//3

	s1.assign("hello");//4
	s1.assign("hello", 3);//5
	s2.assign(s1);//6
	s1.assign(10, 'a');//7
	
	return 0;
}

总结：string 的赋值方式很多，operator=这种方式比较常用。

1.4 string 字符串拼接

功能描述：

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

函数原型：

• string& operator+=(const char* str);//重载 += 操作符
• string& operator+=(const char c);//重载 += 操作符
• string& operator+=(const string& str);//重载 += 操作符
• string& append(const char* s);//把char* 类型字符串连接到当前字符串结尾
• string& append(const char* s, int n);//把char* 类型字符串的前 n 个字符连接到当前的字符串结尾
• string& append(const string& s);//同 operator+=(const string& str);
• string& append(const string& s, int pos, int n);//字符串从 pos 开始的 n 个字符连接到字符串结尾。

示例：

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

//string 的赋值操作
int main() {
	string s1 = "I";
	s1 += " am";//1
	s1 += ':';//2
	string s2 = "lixi";
	s1 += s2;//3
	
	s1.append("...");//4
	s1.append("my name", 3);//5
	s1.append(s2);//6
	s1.append(s2, 1, 2);//7
	
	return 0;
}

总结：字符串拼接的重载版本很多，初学阶段记住几种即可。

1.5 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* s, int pos, int n) const;//从 pos 位置查找 s 的前 n 个字符第一次位置

• int find(const char c, int pos = 0) const;//查找字符 c 第一次出现位置

• int rfind(const string& str, int pos = npos) const;//查找 str 最后一次位置，从 pos 开始查找

• int rfind(const char* s, int pos = npos) const;//查找 s 最后一次位置，从 pos 开始查找

• int rfind(const char* s, int pos, int n) const;//从 pos 位置查找 s 的前 n 个字符最后一次位置

• int rfind(const char c, int pos = 0) const;//查找字符 c 最后一次出现位置

• string& replace(int pos, int n, const string& str);//替换从 pos 开始 n 个字符为字符串 str

• string& replace(int pos, int n, const char* s);//替换从 pos 开始 n 个字符为字符串 s

示例：

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

int main() {
//string 的查找操作
	string s1 = "abcdefde";
	int pos = str1.find("de");//1.返回查找指定字符串在字符串中位置
	if (pos == -1) {
		cout << "未找到";
	}
	str1.rfind("de");//5.

//string 的替换操作
	s1.(0, 3, "xyzop");//9.指定多少个字符都会替换进去
	
	return 0;
}

总结：

• find 从左往右查找，rfind 从右往左查找
• find 找到字符串后返回查找的第一个字符位置，找不到返回 -1
• replace 替换时，要指定从哪个位置起，多少个字符，替换成怎么样的字符串，并且要替换的字符串无论多少个字符，都会替换进去

1.6 string 字符串比较

功能描述：

• 字符串之间的比较

比较方式：

• 字符串比较是按字符的 ASCII 码进行对比
  • = 返回 0

  • 返回 1

  • < 返回 -1

函数原型：

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

示例：

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

//字符串比较操作
int main() {
	string s1 = "abcdefde";
	string s2 = "abcdefg";
	if (s1.compare(s2) == 0) {
		cout << "s1 == s2" << endl;
	}
	else if (s1.compare(s2) > 0) {
		cout << "s1 > s2" << endl;
	}
	else {
		cout << "s1 < s2" << endl;
	}
	return 0;
}

总结：

• 字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小意义并不是很大

1.7 string 字符存取

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

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

示例：

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

//string 字符存取操作
int main() {
	string s1 = "abcdefde";
	
	for (int i = 0; i < s1.size(); i++) {//1.
		s1[i] = 'a';//修改
		cout << s1[i] << " ";//访问
	}
	for (int i = 0; i < s1.size(); i++) {//2.
		s1[i] = 'b';//修改
		cout << s1.at(i) << " ";//访问
	}
	return 0;
}

总结：string 字符串中单个字符存取有两种方式，利用 [ ] 或 at

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

//string 插入和删除操作
int main() {
	string s1 = "abcdefde";
	
	s1.insert(1, "111");//1.

	s1.erase(1, 3);//4.
	
	return 0;
}

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

1.9 string 子串

功能描述：

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

函数原型：

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

示例：

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

//string 子串操作
int main() {
	string s1 = "abcdefde";
	
	string s2 = str.substr(2, 3);
	
	return 0;
}

实例：

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

int main() {
	string email = "zhangsan@sina.com";
	//从邮箱地址获取用户名信息
	int pos = email.find("@");
	string userName = email.substr(0, pos);
	
	return 0;
}

总结：灵活的运用求子串功能，可以在实际开发中获取有用的信息。

2. vector 容器

2.1 vector 基本概念

功能：

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

vector 与 普通数组区别：

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

动态扩展：

• 并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。

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

2.2 vector 构造函数

功能描述：

• 创建 vector 容器

函数原型：

• vector<T> v; // 采用模板实现类实现，默认构造函数
• vector(v.begin(), v.end()); //将 v[begin(), end()) 区间中的元素拷贝给本身

是一个前闭后开区间，begin() 的值可以取到，end() 的值是取不到的。（因为 end() 的值没有意义，不是我们想要的）

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

示例：

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

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

//vector 构造函数
int main() {
	vector<int> v1;//1.默认构造，无参构造
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	printVector(v1);

	vector<int> v2(v1.begin(), v1.end());//2.
	printVector(v2);

	vector<int> v3(6, 6);//3.
	printVector(v3);

	vector<int> v4(v2);//4.拷贝构造
	printVector(v4);

	return 0;
}

总结：vector 的多种构造方式没有可比性，灵活使用即可。

2.3 vector 赋值操作

功能描述：

• 给 vector 容器进行赋值

函数原型：

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

示例：

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

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

//vector 赋值操作
int main() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	printVector(v1);

	vector<int> v2;
	v2 = v1;//1.
	printVector(v2);

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

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

	return 0;
}

总结：vector 赋值方式比较简单，使用 operator=，或者 assign 都可以

2.4 vector 容量和大小

功能描述：

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

函数原型：

• empty(); // 判断容器是否为空
• capacity; // 容器的容量
• size(); // 返回容器中元素的个数

容量永远都 大于等于 大小。

• resize(int num); // 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置，若容器变短，则末尾超出容器长度的元素被删除。
• resize(int num, elem); // 重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置，若容器变短，则末尾超出容器长度的元素被删除。

示例：

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

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

//vector 容量和大小
int main() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	printVector(v1);
	
	if (v1.empty()) {//1.
		cout << "v1 为空" << endl;
	}
	else {
		cout << v1.capacity() << endl;//2.//16
		cout << v1.size() << endl;//3.//10
	}
	
	v1.resize(5);//4.如果重新指定的比原来短了，超出的部分会删除掉
	printVector(v1);

	v1.resize(10, 100);//5.指定默认的填充值（不指定默认为 0），如果重新指定比原来长，用默认的填充值填充新的位置
	printVector(v1);

	return 0;
}

总结：

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

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 之间（[start, end)）的元素

插入（insert）和删除（erase）都必须要提供迭代器，而不能是提供下标。

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

示例：

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

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

//vector 插入和删除操作
int main() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);//1.尾插
	}
	printVector(v1);
	
	v1.pop_back();//2.尾删
	printVector(v1);

	v1.inert(v1.begin(), 100);//3.插入
	printVector(v1);
	
	v1.inert(v1.begin(), 2,1000);//4.插入
	printVector(v1);
	
	v1.erase(v1.begin());//5.删除
	printVector(v1);
	
	v1.erase(v1.begin(), v1.end());//6.删除
	printVector(v1);

	v1.clear();//7.清空
	printVector(v1);
	
	return 0;
}

总结：

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

2.6 vector 数据存取

功能描述：

• 对 vector 中的数据的存取操作

函数原型：

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

示例：

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

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

//vector 的数据存取操作
int main() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	printVector(v1);
	
	v1.at(4);//1.
	v1[4];//2.
	v1.front();//3.
	v1.back();//4.
	
	return 0;
}

总结：

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

2.7 vector 互换容器

功能描述：

• 实现两个容器的元素进行交换

函数原型：

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

示例：

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

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

//vector 的数据存取操作
int main() {
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	printVector(v1);
	
	vector<int> v2;
	for (int i = 0; i < 10; i++) {
		v2.push_back(i + 10);
	}
	printVector(v2);

	v1.swap(v2);
	printVector(v1);
	printVector(v2);
	
	return 0;
}

实例：巧用 swap 可以收缩内存空间。

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

int main() {
	vector<int> v;
	for (int i = 0; i < 10000; i++) {
		v.push_back(i);
	}
	cout << v.capacity() << endl;
	cout << v.size() << endl;
	
	v.resize(3);
	cout << v.capacity() << endl;//容量不变
	cout << v.size() << endl;

	//巧用 swap 收缩内存空间
	vector<int>(v).swap(v);
	cout << v.capacity() << endl;
	cout << v.size() << endl;
	
	return 0;
}

1. 创建一个匿名容器，调用拷贝构造函数，用 v 目前所用的元素个数来初始化，所以匿名容器的容量是 3，大小也是 3。
2. 调用 swap 函数将 匿名容器与 v 容器做了交换，所以 v 的容量是 3，大小也是 3。
3. 匿名容器在当前行执行完之后所占的内存由系统马上回收。

总结：swap 可以使两个容器互换，可以达到实用的收缩内存的效果。

2.8 vector 预留空间

功能描述：

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

函数原型：

• reserve(int len); //容器预留 len 个元素长度，预留位置不初始化，元素不可访问。

示例：

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

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

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

3. deque 容器

3.1 deque 容器基本概念

功能：

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

deque 与 vector 区别：

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

deque 内部工作原理：

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

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

当缓冲区中数据（头部/尾部）插满以后，再有新的数据插入时，会再申请一块新的缓冲区，插入数据进去，并在中控器中记录缓冲区的地址。

所以它对头部和尾部都可以快速的插入删除。只不过访问数据的速度没有 vector 那么快，因为需要通过中控器并且跨缓冲区来访问数据，访问效率较低。

• deque 容器的迭代器也是支持随机访问的。

3.2 deque 构造函数

功能描述：

• deque 容器构造

函数原型：

• deque<T> deqT; //默认构造函数
• deque(deq.begin(), deq.end()); //构造函数将 [begin(), end()) 区间中的元素拷贝给本身
• deque(n, elem); //构造函数将 n 个 elem 拷贝给本身
• deque(const deque& deq); //拷贝构造函数

示例：

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

void printDeque(const deque<int> &deq) {//只读容器
	for (deque<int>::const_iterator it = deq.begin(); it != deq.end(); it++) {//只读迭代器
		//*it = 100;//容器里的数据不可以修改了
		cout << *it << " ";
	}
	cout << endl;
}

//deque 构造函数
int main() {
	deque<int> d1;//1.默认构造，无参构造
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	printDeque(d1);

	deque<int> d2(d1.begin(), d1.end());//2.
	printDeque(d2);

	deque<int> d3(6, 6);//3.
	printDeque(d3);

	deque<int> d4(d2);//4.拷贝构造
	printDeque(d4);

	return 0;
}

只读容器要使用只读迭代器 (const_iterator) 来访问。

总结：deque 容器和 vector 容器的构造方式几乎一致，灵活使用即可。

3.3 deque 赋值操作

功能描述：

• 给 deque 容器进行赋值

函数原型：

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

示例：

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

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

//deque 赋值操作
int main() {
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	printDeque(d1);

	deque<int> d2;
	d2 = d1;//1.
	printDeque(d2);

	deque<int> d3;
	d3.assign(d1.begin(), d1.end());//2.
	printDeque(d3);

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

	return 0;
}

总结：deque 赋值操作也与 vector 相同，需熟练掌握。

3.4 deque 大小操作

功能描述：

• 对 deque 容器的大小操作

函数原型：

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

deque 容器没有容量的概念，因为它的内部结构中根本没有容量这一个限制，它可以往后面开辟新的缓冲区，中控区只加一个地址就可以了，维护开辟的缓冲区。

示例：

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

void printDeque(const deque<int> &d) {
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
//deque 容量和大小
int main() {
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	printDeque(d1);
	
	if (d1.empty()) {//1.
		cout << "d1 为空" << endl;
	}
	else {
		cout << d1.size() << endl;//2.//10
	}
	
	d1.resize(5);//3.如果重新指定的比原来短了，超出的部分会删除掉
	printDeque(d1);

	d1.resize(10, 100);//4.指定默认的填充值（不指定默认为 0），如果重新指定比原来长，用默认的填充值填充新的位置
	printDeque(d1);

	return 0;
}

总结：

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

3.5 deque 插入和删除

功能描述：

• 对 deque 容器进行插入、删除操作

函数原型：
两端插入操作：

• push_back(elem); //尾部插入元素 elem
• push_front(elem); //头部插入元素 elem
• pop_back(); //删除最后一个元素
• pop_front(); //删除第一个元素

指定位置操作：

• insert(pos, elem); //在 pos 位置插入元素 elem，返回新数据的位置
• insert(pos, num, elem); //在 pos 位置插入 num 个元素 elem，无返回值
• insert(pos, beg, end); //在 pos 位置插入 [beg, end) 区间的数据，无返回值。
• erase(pos); //删除 pos 位置的元素，返回下一个数据的位置
• erase(start, end); //删除 [start, end) 区间的数据，返回下一个数据的位置

插入（insert）和删除（erase）都必须要提供迭代器，而不能是提供下标。

• clear(); //清空容器中所有元素

示例：

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

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

//deque 插入和删除操作
int main() {
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);//1.尾插
		d1.push_front(i + 10);//2.头插
	}
	printDeque(d1);
	
	d1.pop_back();//3.尾删
	d1.pop_front();//4.头删
	printDeque(d1);

	d1.inert(d1.begin(), 100);//1.插入
	printDeque(d1);
	
	d1.inert(d1.begin(), 2,1000);//2.插入
	printDeque(d1);
	
	deque<int> d2;
	d2.push_back(1);
	d2.push_back(1);
	d2.push_back(1);
	
	d1.inert(d1.begin(), d2.begin(), d2.end());//3.按照区间插入
	printDeque(d1);

	d1.erase(d1.begin());//4.删除
	printDeque(d1);
	
	d1.erase(d1.begin(), d1.end());//5.按照区间删除
	printDeque(d1);

	d1.clear();//6.清空
	printDeque(d1);
	
	return 0;
}

总结：

• 插入和删除提供的位置都是迭代器！
• 尾插 — push_back
• 尾删 — pop_back
• 头插 — push_front
• 头删 — pop_front

3.6 deque 数据存取

功能描述：

• 对 deque 中的数据的存取操作

函数原型：

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

示例：

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

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

//deque 的数据存取操作
int main() {
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	printDeque(v1);
	
	d1.at(4);//1.
	d1[4];//2.
	d1.front();//3.
	d1.back();//4.
	
	return 0;
}

总结：

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

3.7 deque 排序

功能描述：

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

算法：

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

示例：

#include <iostream>
#include <deque>
#include <algorithm>//标准算法头文件
using namespace std;

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

int main() {
	deque<int> d1;
	d1.push_back(10);
	d1.push_back(30);
	d1.push_back(20);
	d1.push_back(40);
	printDeque(d1);
	
	//排序
	sort(d1.begin(), d1.end());//默认排序规则是升序排列（从小到大）
	printDeque(d1);

	return 0;
}

• 对于支持随机访问的迭代器的容器，都可以利用 sort 算法直接对其进行排序。
• sort 算法的默认排序规则是升序排列（从小到大）。

总结：sort 算法非常实用，使用时包含头文件 algorithm 即可。

4. stack 容器

4.1 stack 基本概念

概念：stack 是一种先进后出（First In Last Out, FILO）的数据结构，它只有一个出口。

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。
栈中进入数据称为 — 入栈 push
栈中弹出数据称为 — 出栈 pop

栈可以判断容器是否为空么？— 可以（empty）
栈可以返回元素个数么？— 可以（size）

4.2 stack 常用接口

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

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

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

int main() {
	stack<int> s;
	
	s.push(10);//入栈/压栈
	s.push(20);
	s.push(30);
	s.push(40);

	cout << s.size() << endl;//查看栈的大小

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

	cout << s.size() << endl;//查看栈的大小

	return 0;
}

总结：

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

5. queue 容器

5.1 queue 基本概念

概念：queue 是一种先进先出（First In First Out, FIFO）的数据结构，它只有一个出口。

队列容器允许从一端新增元素，从另一端移除元素。
队列中只有队头和队尾可以被外界使用，因此队列不允许有遍历行为。
队列中进数据称为 — 入队 push
队列中出数据称为 — 出队 pop

5.2 queue 常用接口

功能描述：队列容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

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

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

int main() {
	queue<int> q;
	
	q.push(10);//入队
	q.push(20);
	q.push(30);
	q.push(40);

	cout << q.size() << endl;//查看队列的大小

	//只要队列不为空，查看队头，查看队尾，出队。
	while(!q.empty()) {
		cout << q.front() << " ";//查看队头元素
		cout << q.back() << " ";//查看队尾元素
		q.pop();//出队
	}

	cout << q.size() << endl;//查看队列的大小

	return 0;
}

总结：

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

6. list 容器

6.1 list 容器基本概念

功能：将数据进行链式存储

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

• 链表的组成：链表有一系列结点组成
• 节点的组成：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。

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

• 双向：结点的指针域中有两个指针，一个指针指向前一个结点（prev），一个指针指向后一个结点（next），每个结点既记录了上一个结点，又记录了下一个结点。
• 循环：最后一个结点的下一个结点记录第一个结点（next 指针指向第一个结点），第一个结点的前一个结点记录最后一个结点（prev 指针指向最后一个结点）。
  

由于链表的存储方式并不是连续的内存空间，因此链表 list 中的迭代器只支持前移和后移，属于双向迭代器。

迭代器只能通过指针域一个一个找，不能跳跃式访问

list 的优点：

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

list 的缺点：

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

链表的遍历速度没有数组快，需要通过指针域不断的访问下一个元素。

list 有一个重要的性质，插入操作和删除操作都不会造成原有 list 迭代器失效，这在 vector 是不成立的。（vector 容器在动态扩展的过程中会使原有迭代器失效）

总结：STL 中 list 和 vector 是两个最常被使用的容器，各有优缺点。

6.2 list 构造函数

功能描述：

• 创建 list 容器

函数原型：

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

示例：

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

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

int main() {
	list<int> l1;//1.默认构造

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

	printList(l1);

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

	list<int> l3(5, 10);//3.
	printList(l3);

	list<int> l4(l2);//4.
	printList(l4);

	return 0;
}

总结：list 构造方式同其他几个 STL 常用容器，熟练掌握即可

6.3 list 赋值和交换

功能描述：

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

函数原型：

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

示例：

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

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

//list 赋值和交换操作
int main() {
	list<int> l1;
	for (int i = 0; i < 10; i++) {
		l1.push_back(i);
	}
	printList(l1);

	list<int> l2;
	l2 = l1;//1.
	printList(l2);

	list<int> l3;
	l3.assign(l1.begin(), l1.end());//2.
	printList(l3);

	list<int> l4;
	l4.assign(10, 100);//3.
	printList(l4);

	l3.swap(l4);//4.
	printList(l3);
	printList(l4);
	
	return 0;
}

总结：list 赋值和交换操作能够灵活运用即可

6.4 list 大小操作

功能描述：

• 对 list 容器的大小操作

函数原型：

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

示例：

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

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

//list 容量和大小
int main() {
	list<int> l1;
	for (int i = 0; i < 10; i++) {
		l1.push_back(i);
	}
	printList(l1);
	
	if (l1.empty()) {//1.
		cout << "l1 为空" << endl;
	}
	else {
		cout << l1.size() << endl;//2.//10
	}
	
	l1.resize(5);//3.如果重新指定的比原来短了，超出的部分会删除掉
	printList(l1);

	l1.resize(10, 100);//4.指定默认的填充值（不指定默认为 0），如果重新指定比原来长，用默认的填充值填充新的位置
	printList(l1);

	return 0;
}

总结：

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

6.5 list 插入和删除

功能描述：

• 对 list 容器进行插入、删除操作

函数原型：

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

插入（insert）和删除（erase）都必须要提供迭代器，而不能是提供下标。

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

示例：

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

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

//deque 插入和删除操作
int main() {
	list<int> l1;
	for (int i = 0; i < 10; i++) {
		l1.push_back(i);//1.尾插
		l1.push_front(i + 10);//2.头插
	}
	printList(l1);
	
	l1.pop_back();//3.尾删
	l1.pop_front();//4.头删
	printList(l1);

	l1.inert(l1.begin(), 100);//1.插入
	printList(l1);
	
	l1.inert(l1.begin(), 2,1000);//2.插入
	printList(l1);
	
	list<int> l2;
	l2.push_back(1);
	l2.push_back(1);
	l2.push_back(1);
	
	l1.inert(l1.begin(), l2.begin(), l2.end());//3.按照区间插入
	printList(l1);

	l2.erase(++l2.begin());//4.删除
	printList(l2);
	
	l2.erase(l2.begin(), l2.end());//5.按照区间删除
	printList(l2);

	l1.remove(1);//6.移除容器中所有匹配元素
	printList(l1);
	
	l1.clear();//7.清空
	printList(l1);
	
	return 0;
}

双向迭代器支持 ++、–。

总结：

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

6.6 list 数据存取

功能描述：

• 对 list 中的数据的存取操作

函数原型：

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

示例：

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

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

//list 的数据存取操作
int main() {
	list<int> l1;
	for (int i = 0; i < 10; i++) {
		l1.push_back(i);
	}
	printDeque(v1);
	
	l1.front();//1.
	l1.back();//2.
	
	return 0;
}

不可以用 [] 和 at 访问 list 容器中的元素！
原因：list 本质链表，不是用连续线性空间存储数据；迭代器是双向迭代器，也是不支持随机访问的。因此不能跳跃式的访问容器中的元素。

验证迭代器不支持随机访问：

list<int>::iterator it = l1.begin();
it++;//如果即支持 ++ 又支持 -- 是双向迭代器
it--;//如果只支持 ++ 不支持 -- 就是前向迭代器
//it = it + 1;//不支持随机访问

总结：

• front 返回容器第一个元素
• back 返回容器最后一个元素

6.7 list 反转和排序

功能描述：

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

算法：

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

示例：

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

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

bool myCompare(int v1, int v2) {
	//降序：就让第一个数 > 第二个数
	return v1 > v2;
}

int main() {
	list<int> l1;
	l1.push_back(10);
	l1.push_back(30);
	l1.push_back(20);
	l1.push_back(40);
	printList(l1);

	//反转
	l1.reverse();
	printList(l1);
	
	//排序
	l1.sort();//默认排序规则是升序排列（从小到大）
	printList(l1);

	//降序
	l1.sort(myCompare);//指定排序规则
	printList(l1);

	return 0;
}

• 所有不支持随机访问迭代器的容器，不可以用标准算法
• 不支持随机访问迭代器的容器，内部会提供一些对应的成员函数的一些算法
• 排序函数会根据容器的个数选择适应的排序算法，如果数据量级大了，有一套自己的排序规则；如果数据量级小了，它又换一套排序规则，会根据你的数据量级做一个选择性的排序算法。

总结：

• 反转 — reverse
• 排序 — sort（成员函数）

6.8 list 排序自定义类型数据

功能描述：

• 将存放f自定义类型数据的 list 容器进行排序

案例描述：

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

排序规则：

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

示例：

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

class Person {
public:
	Person(string name, int age, int height) {
		m_Name = name;
		m_Age = age;
		m_Height = height;
	}

public:
	string m_Name;
	int m_Age;
	int m_Height;
};

void printList(const list<Person>& l) {
	for (list<Person>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << it->m_Name << " "<< it->m_Age << " "<< it->m_Height << " ";
	}
	cout << endl;
}

bool myCompare(Person& p1, Person& p2) {
	// 按照年龄 排序
	if (p1.m_Age == v2.m_Age) {
	// 年龄相同 按照身高排序
		return p1.m_Height > p2.m_Height;
	} else {
		return p1.m_Age < v2.m_Age;
	}
}

int main() {
	list<int> l1;

	Person p1("zhao", 35, 175);
	Person p2("qian", 45, 180);
	Person p3("sun", 40, 170);
	Person p4("li", 25, 190);
	Person p5("zhou", 35, 160);
	Person p6("wu", 35, 200);

	l1.push_back(p1);
	l1.push_back(p2);
	l1.push_back(p3);
	l1.push_back(p4);
	l1.push_back(p5);
	l1.push_back(p6);

	printList(l1);
	
	//排序
	l1.sort(myCompare);
	printList(l1);

	return 0;
}

• 对于 list 容器而言，如果存放的是自定义数据类型，排序时必须指定排序规则，否则编译器不知道如何进行排序
• 高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂

7. set/multiset 容器

7.1 set 基本概念

特点：

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

本质：

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

关联式容器的特点就是在插入时自动排序。

set 和 multiset 区别：

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

使用这两个容器需要包含头文件 #include <set>

7.2 set 构造和赋值

功能描述：

• 创建 set 容器以及赋值

构造：

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

赋值：

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

示例：

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

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

//set 容器的构造和赋值操作
int main() {
	set<int> s1;

	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(30);//查重复的值不报错，但插入不成功。

	//遍历容器
	printSet(s1);
	
	return 0;
}

总结：

• set 容器插入数据的时候只有 insert 的方式。
• set 容器插入数据的数据会自动排序。

7.3 set 大小和交换

功能描述：

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

函数原型：

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

set 容器不允许重新指定大小，因为 set 容器不允许有重复的元素，而重新指定大小时的默认填充元素是重复的元素，没有意义。

示例：

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

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

//set 容器的大小和交换操作
int main() {
	set<int> s1;

	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(30);//查重复的值不报错，但插入不成功。

	printSet(s1);

	if (s1.empty()) {
		cout << "s1 为空" << endl;
	}
	else {
		cout << s1.size() << endl;
	}

	set<int> s2;

	s2.insert(100);
	s2.insert(400);
	s2.insert(300);
	s2.insert(200);

	printSet(s1);
	printSet(s2);
	s1.swap(s2);
	printSet(s1);
	printSet(s2);
	
	return 0;
}

总结：

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

7.4 set 插入和删除

功能描述：

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

函数原型：

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

set 容器的删除函数的参数可以不提供迭代器，而是提供一个元素，它会把指定的元素给删掉。

示例：

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

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

//set 容器的插入和删除操作
int main() {
	set<int> s1;

	s1.insert(30);
	s1.insert(40);
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);//查重复的值不报错，但插入不成功。

	printSet(s1);

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

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

	s1.erase(s1.begin(), s1.end());//删除区间元素
	s1.clear();//清空容器
	printSet(s1);
	
	return 0;
}

总结：

• 插入 — insert
• 删除 — erase
• 清空 — clear

7.5 set 查找和统计

功能描述：

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

函数原型：

• find(key); //以迭代器的方式查找 key 是否存在，若存在，返回该键的元素的迭代器；若不存在，返回 set.end();
• count(key); //统计 key 的元素个数，对于 set 容器而言，结果是 0 或者 1，因为 set 容器不允许有重复的元素，对于 multiset 容器而言，返回结果可能会 > 1。

示例：

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

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

//set 容器的插入和删除操作
int main() {
	set<int> s1;

	s1.insert(30);
	s1.insert(40);
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);//查重复的值不报错，但插入不成功。

	printSet(s1);

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

总结：

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

7.6 set 和 multiset 区别

学习目标：

• 掌握 set 和 multiset 的区别

区别：

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

示例：

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

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

//set 和 multiset 区别
int main() {
	set<int> s1;

	pair<set<int>::iterator, bool> ret = s1.insert(30);
	if (ret.second) {
		cout << "插入成功" << endl;
	}
	else {
		cout << "插入失败" << endl;
	}
	
	ret = s1.insert(30);//查重复的值不报错，但插入不成功。
	if (ret.second) {
		cout << "插入成功" << endl;
	}
	else {
		cout << "插入失败" << endl;
	}

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

set 容器在插入时会返回一个对组，对组中第一个数据是一个迭代器，会返回元素插入的位置，第二个数据是 一个 bool 数据类型的数据，代表数据是否插入成功。所以对于我们而言，set 容器在插入的时候会告诉你一个数据插入成功还是失败的一个结果。所以它会有插入重复检测。
multiset 容器在插入时会返回一个迭代器，只要插入的数据的类型正确，就会返回元素插入的位置，所以它没有插入重复检测，允许插入重复的数据。

总结：

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

7.7 pair 对组的创建

功能描述：

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

两种创建方式：

• pair<type, type> p(val1,val2);
• pair<type, type> p = make_pair(val1,val2);

示例：

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

//pair 对组的创建
int main() {
	pair<string, int> p("Tom", 30);//1.
	cout << p.first << " " << p.second << endl;
	
	pair<string, int> p2 = make_pair("Tom", 30);//2.
	cout << p2.first << " " << p2.second << endl;
	
	return 0;
}

总结：两种方式都可以创建对组，记住一种即可。

7.8 set 容器排序

功能描述：

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

set 容器如果想要改变容器的排序规则，就要在插入前就指定容器的排序规则。

主要技术点：

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

仿函数就是重载了函数调用运算符() 的类，本质是一个类型。

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

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

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

//set 容器排序内置数据类型
int main() {
	set<int> s1;

	s1.insert(30);
	s1.insert(40);
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);//查重复的值不报错，但插入不成功。

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

	set<int, MyCompare> s2;

	s2.insert(30);
	s2.insert(40);
	s2.insert(10);
	s2.insert(20);//在插入数据后就改不了数据的顺序

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

• 模板参数列表中要放类型，不能放函数名
• 如果用函数打印容器中的数据，得把仿函数写在前面，写声明不行
• 仿函数必须用 const 修饰
• 一般三种方式实现自己的比较器 lambda函数，仿函数，运算符重载

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

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

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

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

public:
	string m_Name;
	int m_Age;
};

class MyCompare {
public:
	bool operator()(const Person& p1, const Person& p2) const{
		return p1.m_Age > p2.m_Age;//降序
	}
};

//set 容器排序自定义数据类型
int main() {
	set<Person, MyCompare> s;

	Person p1("zhao", 24);
	Person p2("qian", 28);
	Person p3("sun", 25);
	Person p4("li", 21);

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

	for (set<Person>::iterator it = s.begin(); it != s.end(); it++) {
		cout << it->m_Name << " " << it->m_Age << endl;
	}
	
	return 0;
}

• 仿函数在了类和使用之间
• 参数const 引用，不会导致拷贝构造出现
• 存放自定义数据类型的 set 容器必须指定排序规则。

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

8. map/ multimap 容器

使用率仅次于 vector 和 list，在 STL 中地位比较高，STL 有一个优点叫高性能高效率说的就是 map 容器。

8.1 map 基本概念

简介：

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

高性能：可以快速地从大量的数据中找到想要的数据，因为 key 起到了索引作用。

本质：

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

优点：

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

map 和 multimap 区别：

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

map 不允许插入重复的元素，后插的重复元素不会插入进去。

8.2 map 构造和赋值

功能描述：

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

函数原型：
构造：

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

赋值：

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

示例：

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

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

//map 容器构造和赋值
int main() {
	map<int,int> m;//1.

	m.insert(pair<int, int>(1, 10));//创建匿名对组，插入 map 容器中
	m.insert(pair<int, int>(4, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(2, 40));

	printMap(m);

	map<int, int> m2(m);//2.
	printMap(m2);
	
	map<int, int> m3;
	m3 = m2;//2.
	printMap(m3);
	
	return 0;
}

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

8.3 map 大小和交换

功能描述：

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

函数原型：

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

示例：

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

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

//map 容器大小和交换
int main() {
	map<int,int> m;//1.

	m.insert(pair<int, int>(1, 10));//创建匿名对组，插入 map 容器中
	m.insert(pair<int, int>(4, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(2, 40));

	printMap(m);
	
	if (m.empty()) {//1.
		cout << "空" << endl;
	}
	else {
		cout << m.size() << endl;//2.
	}
	
	map<int, int> m2;
	m2.insert(pair<int, int>(40, 200));
	m2.insert(pair<int, int>(30, 300));
	m2.insert(pair<int, int>(20, 400));
	
	printMap(m);
	printMap(m2);
	m2.swap(m);//3.
	printMap(m);
	printMap(m2);
	
	return 0;
}

总结：

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

8.4 map 插入和删除

功能描述：

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

函数原型：

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

map 容器的删除函数的参数可以不提供迭代器，而是提供一个元素，它会把 key值为指定元素的对组 给删掉。

示例：

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

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

//map 容器大小和交换
int main() {
	map<int,int> m;//1.

	
	m.insert(pair<int, int>(1, 10));//1.创建匿名对组，插入 map 容器中
	
	m.insert(make_pair(2, 20));//2.make_pair:制造对组，不用指定模板参数

	m.insert(map<int,int>::value_type(3, 30));//3.map 容器的值类型为 pair<int,int>

	m[4] = 40;//4.

	//cout << m[5] << endl; //如果没有在容器中找到 key 为 5的对组，会自动创建一个 key 为 5，value 为 0 的对组插入到容器中，最终在容器中找到 key 为 5 的对组，返回 value 0。
	//[]不建议插入，用途：可以利用 key 访问到 value。
	
	cout << m[4] << endl;

	printMap(m);
	
	m.erase(m.begin());//1.
	printMap(m);

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

	m.erase(m.begin(), m.end());//3.
	m.clear();//4.
	printMap(m);
	
	return 0;
}

• cout << m[5] << endl;
  如果没有在容器中找到 key 为 5的对组，会自动创建一个 key 为 5，value 为 0 的对组插入到容器中，最终在容器中找到 key 为 5 的对组，返回 value 0。
• [ ]不建议用于插入，用途：可以利用 key 访问到 value。

总结：

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

8.5 map 查找和统计

功能描述：

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

函数原型：

• find(key); // 以迭代器的方式查找 key 是否存在，若存在，返回该键的元素的迭代器；若不存在，返回 set.end();
• count(key); //统计 key 的元素个数，对于 map 容器而言，结果是 0 或者 1，因为 map 容器不允许有重复的 key 元素，对于 multimap 容器而言，返回结果可能会 > 1。

示例：

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

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

//map 容器大小和交换
int main() {
	map<int,int> m;

	m.insert(pair<int, int>(1, 10));//创建匿名对组，插入 map 容器中
	m.insert(pair<int, int>(4, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(2, 40));

	printMap(m);
	
	map<int,int>::iterator pos = m.find(3);//1.
	if (pos != m.end()) {
		cout << (*pos).first << " " << pos->second << endl;
	} else {
		cout << "未找到元素" << endl;
	}
	
	m.insert(pair<int, int>(3, 40));//map 不允许插入重复 key 元素，会插入不成功。
	m.count(3);//2.
	printMap(m);
	
	return 0;
}

map 不允许插入重复的 key 元素，后插入的重复元素会插入不进去（不是覆盖）。

总结：

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

8.6 map 容器排序

功能描述：

• map 容器默认排序规则为按照 key 值进行从小到大排序，掌握如何改变排序规则

主要技术点：

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

示例：

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

class MyCompare {
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};

//map 容器排序
int main() {
	map<int,int> m;//默认从小到大

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

	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {
		cout << (*it).first << " " << it->second << endl;
	}
	
	map<int,int， MyCompare> mc;//利用仿函数实现从大到小排序

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

	for (map<int, int, MyCompare>::iterator it = mc.begin(); it != mc.end(); it++) {
		cout << (*it).first << " " << it->second << endl;
	}
	
	return 0;
}

总结：

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