C++ STL 学习总结

gsd47

已于 2024-02-16 23:22:28 修改

阅读量426

点赞数 5

分类专栏： C++ 黑马（总结）文章标签： c++ 学习开发语言

于 2024-02-03 13:09:11 首次发布

本文链接：https://blog.csdn.net/weixin_45231931/article/details/135951515

版权

C++ 黑马（总结）专栏收录该内容

6 篇文章 0 订阅

订阅专栏

STL

STL（标准模板库 standard template library）提供了一系列通用的模板类和函数，用于处理数据。

STL&vector容器

vector存放内置数据类型：

注意：
1、在创建vector容器对象时，需指定容器数据类型。
2、通过迭代器iterator对容器元素进行遍历。
3、使用vector时，需包含头文件vector。
4、for_each遍历函数需要包含头文件algorithm。

案例代码：

#include <vector> // vector头文件
#include <algorithm> // for_each头文件
using namespace std;
void printV(int &val)
{
	cout << val << "\t";
}
int main()
{
	vector<int> v; // 创建一个vector容器，数组
	for (int i = 0; i < 4; i++) // 向容器中插入数据
		v.push_back((i + 1) * 10);
	// 通过迭代器访问容器中的数据
	vector<int>::iterator itBegin = v.begin(); // 起始迭代器，指向容器中第一个元素
	vector<int>::iterator endBegin = v.end(); // 结束迭代器，指向容器中最后一个元素的下一个位置

	// 第一种遍历方式
	while (itBegin != endBegin)
	{
		cout << *itBegin << "\t";
		itBegin++;
	}
	cout << endl;
	// 第二种遍历方式
	for(vector<int>::iterator itBegin = v.begin(); itBegin != v.end();itBegin++)
		cout << *itBegin << "\t";
	cout << endl;
	// 第三种遍历方式
	for_each(itBegin, endBegin, printV); // 参数：头节点，尾节点，回调函数（底层是for循环内的函数）
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

注意：迭代器实质是一个指针，因此可以通过 *指针名 解引用的方式来获取数据。

vector存放自定义数据类型：

#include <vector>
using namespace std;
class Person
{
public:
	string m_Name;
	int m_Age;
	Person(string m_Name, int m_Age) :m_Name(m_Name), m_Age(m_Age){}
};
int main()
{
	vector<Person> v; // 创建一个vector容器，数组
	Person p1("孙悟空",23);
	Person p2("猪八戒",24);
	Person p3("唐僧",25);
	Person p4("沙僧", 26);
	// 向容器中插入数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	// 通过迭代器访问容器中的数据
	vector<Person>::iterator itBegin = v.begin();
	vector<Person>::iterator itEnd = v.end();
	// 通过迭代器遍历容器中的数据
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
		cout << it->m_Name << "," << it->m_Age << "\t";
		//cout << (*it).m_Name << "," << (*it).m_Age << "\t";
	cout << endl;

	vector<Person*> v2; // 创建一个vector容器，指针数组，存放的是指向对象的指针
	// 向容器中插入数据
	v2.push_back(&p1);
	v2.push_back(&p2);
	v2.push_back(&p3);
	v2.push_back(&p4);
	// 遍历容器
	for (vector<Person*>::iterator it = v2.begin(); it != v2.end(); it++)
		cout << (*it)->m_Name << "," << (*it)->m_Age << "\t";
		//cout << (**it).m_Name << "," << (**it).m_Age << "\t";
	cout << endl;
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

注意：
若vector容器内是类对象，则可以通过指针名->成员属性或 *指针名.成员属性来访问类内属性。
若vector容器内是类对象的指针，则可以通过 *指针名->成员属性或 *指针名.成员属性的方式来访问类内属性。（因为vector<类名>的操作本质上就是创建了一个vector容器，每个容器位置存放指向类对象的指针。因此迭代器指针第一次解引用是指向类对象的指针，第二次解引用为类对象本身）

vector容器嵌套容器：
案例代码：

#include <vector>
using namespace std;
void test()
{
	vector<vector<int>> v; // 创建一个vector容器，vector数组
	// 创建vector容器
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	vector<int> v4;
	// 向容器中插入数据
	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 1);
		v3.push_back(i + 1);
		v4.push_back(i + 1);
	}
	// 将vector容器插入到vector容器里
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	// 通过迭代器遍历容器中的数据
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		// it = *vector<int>，it指向的是vector<int>的地址，需要在此遍历vector<int>的容器拿到数据
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
			cout << *vit << "\t";
		cout << endl;
	}
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
vector容器-构造函数：

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

vector和数组的区别：
1、数组是静态空间，在初始化时分配好内存空间。
2、vector可以动态扩展内存空间，申请一块新的内存空间并拷贝原有空间，将原有内存空间释放。

案例代码：

#include <vector>
void printVector(vector<int>& v);
void test()
{
	vector<int> v; // 默认构造 无参构造
	for (int i = 0; i < 10; i++)
		v.push_back(i+1);
	printVector(v);

	vector<int> v2(v.begin(),v.end()); // 通过区间方式进行构造
	printVector(v2);
	
	vector<int> v3(10,1); // n个elem方式构造
	printVector(v3);

	vector<int >v4(v2); // 拷贝构造
	printVector(v4);
}
void printVector(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
vector容器-赋值操作：

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

案例代码：

#include <vector>
void printVector(vector<int> &v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
		v.push_back(i+1);

	vector<int> v2;
	v2 = v;
	printVector(v2);

	vector<int> v3;
	v3.assign(v2.begin(),v2.end());
	printVector(v3);

	vector<int> v4;
	v4.assign(10,1);
	printVector(v4);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
vector容器-容量和大小：

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

案例代码：

#include <vector>
void printVector(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
		v.push_back(i + 1);
	if (v.empty())
		cout << "vector is null" << endl;
	else
	{
		printVector(v);
		cout << "capacitty = " << v.capacity() << endl;
		cout << "size = " << v.size() << endl;
	}
	v.resize(15);
	printVector(v);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
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 <vector>
void printVector(vector<int> v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	vector<int> v;
	for (int i = 0; i < 10; i++)
		v.push_back((i + 1) * 10); // 尾插
	printVector(v);

	v.pop_back(); // 删除最后一个元素
	printVector(v);

	v.insert(v.begin(), 100); // 指定位置插入元素
	printVector(v);
	v.insert(v.begin(),3,100);
	printVector(v);

	v.erase(v.begin()); // 删除指定元素
	printVector(v);

	v.clear();
	printVector(v);

	v.erase(v.begin(),v.end()); // 删除全部元素
	printVector(v);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
vector容器-数据存取：

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

案例代码：

#include <vector>
void printVecMode_1(vector<int> &v)
{
	for (int i = 0; i < v.size(); i++)
		cout << v.at(i) << "\t";
	cout << endl;
}
void printVecMode_2(vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
		cout << v[i] << "\t";
	cout << endl;
}
void test()
{
	vector<int> v;
	for (int i = 0; i < 5; i++)
		v.push_back((i + 1) * 10);
	cout << "at()方式读取数据：" << endl;
	printVecMode_1(v);
	cout << "[]方式读取数据：" << endl;
	printVecMode_2(v);

	cout << "v.front()访问到的元素为：" << v.front() << endl;
	cout << "v.back()访问到的元素为：" << v.back() << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
vector容器-互换容器：

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

案例代码：

#include <vector>
void printVector(vector<int> v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	vector<int> v1;
	vector<int> v2;
	for (int i = 0; i < 5; i++)
		v1.push_back(i+1);
	cout << "v1遍历：";
	printVector(v1);
	for (int i = 5; i > 0; i--)
		v2.push_back(i);
	cout << "v2遍历：";
	printVector(v2);

	// swap(vec); // 将vec与本身的元素互换
	cout << "交换后：" << endl;
	v1.swap(v2);
	cout << "v1遍历：";
	printVector(v1);
	cout << "v2遍历：";
	printVector(v2);
	
	// swap用途：收缩内存
	cout << "v1.capacity = " << v1.capacity() << endl;
	cout << "v1.size = " << v1.size() << endl;
	vector<int>(v1).swap(v1); 
	/* vector<int>(v1)是调用拷贝构造创建v1副本的匿名对象 ，此时匿名对象的size和capacity为5，v1的size和capacity分别为5和6，
	   在调用swap函数进行容器互换后，v1容器的size和capacity为5，匿名对象的size和capacity分别为5和6。当前行执行结束后，系统会
	   立即释放回收匿名对象。因此swap函数可以做到收缩内存的效果。*/ 
	cout << "收缩后：" << endl;
	cout << "v1.capacity = " << v1.capacity() << endl;
	cout << "v1.size = " << v1.size() << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

注意：vector< int >(v1)是调用拷贝构造创建v1副本的匿名对象，此时匿名对象的size和capacity为5，v1的size和capacity分别为5和6，在调用swap函数进行容器互换后，v1容器的size和capacity为5，匿名对象的size和capacity分别为5和6。当前行执行结束后，系统会立即释放回收匿名对象。因此swap函数可以做到收缩内存的效果。

vector容器-预留空间：

reserve(int len); // 容器预留len个元素长度，预留位置不初始化，元素不可访问
注意：如果数据量比较大，一开始就可以使用reserve函数预留空间。

案例代码：

#include <vector>
using namespace std;
void test()
{
	// reserve(int len); // 容器预留len个元素长度，预留位置不初始化，元素不可访问
	// 如果数据量比较大，一开始就可以使用reserve函数预留空间
	vector<int> v;
	int *p = NULL,num = -1;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i + 1);
		// vector每一次动态扩展都需要将原容器元素拷贝到新容器里并释放掉原容器，统计动态扩展次数
		if (p != &v[0]) // 若v[0]的地址与p一开始指向的不相等，则证明更换了一次容器
		{
			p = &v[0];
			num ++ ;
		}
	}
	cout << "动态扩展次数 = " << num << endl;

	vector<int> v2;
	v2.reserve(100000);
	*p = NULL, num = -1;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i + 1);
		if (p != &v[0]) 
		{
			p = &v[0];
			num++;
		}
	}
	cout << "预留空间后动态扩展次数 = " << num << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

STL&string容器

string容器-构造函数：
char* 是一个指针，string类内部封装了char * 用于管理这个类。

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

案例代码：

void test()
{
	string s1; // 默认构造

	const char* str = "hello world";
	string s2(str); // 使用字符串初始化
	cout << s2 << endl;
	cout << "s2 = " << s2 << endl;

	string s3(s2); // 使用一个string对象初始化另一个string对象
	cout << "s3 = " << s3 << endl;

	char ch = 'a';
	string s4(5, ch);
	cout << "s4 = " << s4 << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
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 <string>
void test()
{
	// 1
	string str = "hello world"; 
	cout << str << endl;

	// 2
	string str2 = str; 

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

	// 4
	string str4;
	str4.assign(str); 
	cout << str4 << endl;

	// 5
	string str5;
	str5.assign(str,6); 
	cout << str5 << endl;

	// 6
	string str6;
	str6.assign("hello wjc"); 
	cout << str6 << endl;

	// 7
	string str7;
	str7.assign(5,'a'); 
	cout << str7 << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
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 <string>
int main()
{
	// 1
	char chArr[20] = "world";
	string str1 = "hello";
	str1 += chArr;
	cout << "str1 = " << str1 << endl;

	// 2
	string str2 = "abc";
	str2 += 'd';
	cout << "str2 = " << str2 << endl;

	// 3
	string str3 = "hello";
	str3 += "world";
	cout << "str3 = " << str3 << endl;

	// 4
	char chArr2[20] = "world";
	string str4 = "hello";
	str4.append(chArr2);
	cout << "str4 = " << str4 << endl;

	// 5
	char chArr3[20] = "world";
	string str5 = "hello";
	str5.append(chArr3);
	cout << "str5 = " << str5 << endl;

	// 6
	string str6 = "hello";
	str6.append("world");
	cout << "str6 = " << str6 << endl;

	// 7
	string str7 = "abcdefg";
	string sp = "111";
	str7.append(sp,0,3);
	cout << "str7 = " << str7 << endl;

	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
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; // 从pos索引的位置往前找，返回目标索引值，pos为空则默认从最后一个往前找
int rfind(const char* s, int pos = npos) const; // 从pos索引的位置往前找，返回目标索引值，pos为空则默认从最后一个往前找
int rfind(const char* s, int pos, int n) const; // 从pos索引的位置往前s的前n个字符找，返回目标索引值
int rfind(const char c,int pos = 0) const; // 从pos索引的位置往前找，返回目标索引值

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

find和rfind的区别：find是从左往右找，rfind是从右往左找。

案例代码：

int main()
{
	int site;
	// find::1
	string str_find1 = "hello";
	site = str_find1.find("e", 0);
	cout << "str_find1 = " << site << endl;

	// find::2
	string str_find2 = "hello";
	char arr1[2] = "o";
	site = str_find2.find(arr1, 0);
	cout << "str_find2 = " << site << endl;

	// find::3
	string str_find3 = "hello";
	char arr2[3] = "lo";
	site  = str_find2.find(arr2, 0, 1);
	cout << "str_find3 = " << site << endl;

	// find::4
	string str_find4 = "hello";
	site = str_find4.find('l');
	cout << "str_find4 = " << site << endl;

	// rfind::1
	string str_rfind1 = "abcdefg";
	site = str_rfind1.rfind("de", 6);
	cout << "str_rfind1 = " << site << endl;
	
	// rfind::2
	string str_rfind2 = "abcdefg";
	site = str_rfind2.rfind("de",6);
	cout << "str_rfind2 = " << site << endl;
	
	// rfind::3
	string str_rfind3 = "abcdefg";
	site = str_rfind3.rfind("de",6,1);
	cout << "str_rind3 = " << site << endl;

	// rfind::4
	string str_rind4 = "abcdefg";
	site = str_rind4.rfind('e', 6); 
	cout << "str_rind4 = " << site << endl;

	// repalce::1
	string str_replace1 = "abcdefg";
	str_replace1.replace(2,3,"1111"); // 当替换字符超过替换个数时，不会对替换字符进行数量削减
	cout << "str_replace1 = " << str_replace1 << endl;

	// replace::2
	string str_replace2 = "abcdefg";
	char arr3[5] = "1111";
	str_replace2.replace(2,3,arr3);
	cout << "str_replace2 = " << str_replace2 << endl;

	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
string容器-字符串比较：

int compare(const string &s) const;
int compare(const char *s) const;
比较方式：字符串比较有按字符的ASCII码进行对比， = 返回0，> 返回1，< 返回-1

案例代码：

int main()
{
	string str1 = "abcde";
	string str2 = "ab";
	string str3 = "abcde";
	if (str1.compare(str3) == 0)
		cout << "相等" << endl;
	else if(str1.compare(str3) == 1)
		cout << "大于" << endl;
	else
		cout << "小于" << endl;
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
string容器-字符串存取：
1、通过[]访问单个字符。
2、通过at()方式访问单个字符。
案例代码：

int main()
{
	string str = "hello world";
	for (int i = 0; i < str.size(); i++)
		cout << str[i] << " ";
	
	cout << endl;
	cout << "str.at(2) = " << str.at(2) << endl;

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

	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
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个字符，n默认为删除pos开始后的全部

案例代码：

int main()
{
	string str = "abcde";
	char chArr[3] = "11";
	str.insert(2,chArr);
	cout << "str = " << str << endl;

	string str2 = "abcde";
	str2.insert(2,"11");
	cout << "str2 = " << str2 << endl;

	string str3 = "abcde";
	str3.insert(2,2,'1');
	cout << "str3 = " << str3 << endl;

	string str4 = "abcde";
	str4.erase(2,2);
	cout << "str4 = " << str4 << endl;

	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
string容器-子串获取：

string::substr(int pos,int n) pos为截取位置，n的截取个数

案例代码：

int main()
{
	// string::substr(int pos,int n) pos为截取位置，n的截取个数
	string str = "abcde";
	string substr = str.substr(1,2);
	cout << "substr = " << substr << endl;

	// 实际用途
	string email = "zhangsan@sina.com";
	int pos = email.find("@");
	cout << "pos = " << pos << endl;
	string name = email.substr(0,pos);
	cout << "name = " << name << endl;
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

STL&deque容器

deque容器-构造函数：

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

deque内部工作原理：内部有个中控器，维护每段缓冲区的内容，缓冲区中存放真实数据。中控器维护的是每个缓冲区的地址，使用deque时像一片连续的内存空间。

案例代码：

#include <deque>
void printDeque(const deque<int> deq) // const限定后 迭代器也需要const限定 否则报错
{
	for (deque<int>::const_iterator it = deq.begin(); it != deq.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	deque<int> deq;
	for (int i = 0; i < 5; i++)
		deq.push_back(i+1);
	printDeque(deq);

	deque<int> deq2(deq.begin(),deq.end());
	printDeque(deq2);

	deque<int> deq3(5,100);
	printDeque(deq3);

	deque<int> deq4(deq3);
	printDeque(deq3);
}
int main()
{
	test();
	system("pause");
	return 0;
}

注意：
1、使用deque容器时，需包含头文件deque。
2、若deque对象被const限定，则迭代器也需要被const限定，否则会报错。

输出结果：
在这里插入图片描述
deque容器-赋值操作：

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

案例代码：

#include <deque>
void printDeque(const deque<int> deq) // const限定后 迭代器也需要const限定 否则报错
{
	for (deque<int>::const_iterator it = deq.begin(); it != deq.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
int main()
{
	deque<int> d1;
	for (int i = 0; i < 5; i++)
		d1.push_back(i+1);
	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(5,10);
	printDeque(d4);

	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
deque容器-大小操作：

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

案例代码：

#include <deque>
void printDeque(const deque<int> deq) // const限定后 迭代器也需要const限定 否则报错
{
	for (deque<int>::const_iterator it = deq.begin(); it != deq.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
int main()
{
	deque<int> d1;
	for (int i = 0; i < 5; i++)
		d1.push_back(i + 1);
	printDeque(d1);
	if (d1.empty())
		cout << "该deque容器为空" << endl;
	else
	{
		cout << "deque容器大小 = " << d1.size() << endl;
		d1.resize(2);
		printDeque(d1);
		d1.resize(10);
		printDeque(d1);
		d1.resize(15,6);
		printDeque(d1);
		d1.resize(2, 6);
		printDeque(d1);
	}

	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
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 <deque>
void printDeque(const deque<int> deq)
{
	for (deque<int>::const_iterator it = deq.begin(); it != deq.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	deque<int> deq;
	deq.push_back(100);
	deq.push_front(200);
	deq.push_back(300);
	printDeque(deq);

	deq.pop_back();
	printDeque(deq);
	deq.pop_front();
	printDeque(deq);

	deq.insert(deq.begin(), 10);
	printDeque(deq);

	deq.insert(deq.begin(),2,666);
	printDeque(deq);

	deq.insert(deq.end(),deq.begin(), deq.end());
	printDeque(deq);

	deque<int>::iterator it = deq.begin();
	it++;
	deq.erase(it);
	printDeque(deq);

	deq.erase(deq.begin(),deq.end());
	printDeque(deq);

	deq.clear();
	printDeque(deq);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
deque容器-数据存取：

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

案例代码：

#include <deque>
void test()
{
	deque<int> deq;
	deq.push_back(100);
	deq.push_back(200);
	deq.push_back(300);
	deq.push_front(10);
	deq.push_front(20);
	deq.push_front(30);
	// 30 20 10 100 200 300
	// 1、通过[]方式访问元素
	for (int i = 0; i < deq.size(); i++)
		cout << deq[i] << "\t";
	cout << endl;
	// 2、通过at()方式访问元素
	for (int i = 0; i < deq.size(); i++)
		cout << deq.at(i) << "\t";
	cout << endl;
	cout << "第一个元素为：" << deq.front() << endl;
	cout << "最后一个元素为：" << deq.back() << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
deque容器-排序操作：

sort(iterator beg,iterator end) // 对beg和end区间内元素进行排序
注意：sort函数需包含头文件algorithm。

案例代码：

#include <deque>
#include <algorithm> // sort函数需包含头文件algorithm
void test()
{
	deque<int> deq;
	deq.push_back(100);
	deq.push_back(200);
	deq.push_back(300);
	deq.push_front(10);
	deq.push_front(20);
	deq.push_front(30);
	// 30 20 10 100 200 300
	sort(deq.begin(), deq.end()); // 默认排序规则：升序，从小到大
	// 对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
	// vector容器也可以利用 sort进行排序
	for (int i = 0; i < deq.size(); i++)
		cout << deq.at(i) << "\t";
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

STL&stack容器

stack容器-基本概念：
1、栈容器符合先进后出。
2、栈不允许有遍历行为。
3、栈可以判断容器是否为空吗？可以，empty。
4、栈可以返回元素个数吗？可以，size。
5、入栈push，出栈pop。
6、举例：弹匣、电梯。
在这里插入图片描述
stack容器-常用接口：

构造函数：
stack< T > stk; // stack采用模板类实现，stack对象的默认构造形式
stack(const stack &stk); // 拷贝构造函数
赋值操作：
stack& operator=(const stack &stk); // 重载等号操作符
数据存取：
push(elem); // 向栈顶添加元素
pop(); // 从栈顶移除第一个元素
top(); // 返回栈顶元素
大小操作：
empty(); // 判断堆栈是否为空
size(); // 返回栈的大小

案例代码：

#include <stack>
void test()
{
	stack<int> stk;
	// 入栈
	stk.push(10);
	stk.push(20);
	stk.push(30);
	stk.push(40);
	while (!stk.empty()) // 若栈不为空，则循环出栈
	{
		cout << "栈顶元素为：" << stk.top() << endl;
		stk.pop();
	}
	cout << "栈大小为：" << stk.size() << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

STL&queue容器

queue容器-基本概念：
1、queue 队列容器符合先进先出。
2、队列容器允许一端新增元素，另一端移除元素。
3、队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为。
4、队列中进数据称为入队 push，出数据称为出队 pop。
5、队头front 队尾back。
在这里插入图片描述
queue容器-常用接口：

构造函数：
queue< T > que; // queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); // 拷贝构造函数
赋值操作：
queue& operator=(const queue &que); // 重载等号操作符
数据存取：
push(elem); // 往队尾添加元素
pop(); // 从队头移除第一个元素
back(); // 返回最后一个元素
front(); // 返回第一个元素
大小操作：
empty(); // 判断堆栈是否为空
size(); // 返回栈的大小

案例代码：

#include <queue>
class person
{
public:
	string m_Name;
	int m_Age;
	person(string m_Name, int m_Age) :m_Name(m_Name), m_Age(m_Age) {}
};
void test()
{
	queue<person> q; // 创建队列
	// 准备数据
	person p1("孙悟空",100);
	person p2("猪八戒", 99);
	person p3("唐僧", 98);
	person p4("沙层", 97);
	// 将数据入队
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);
	// 出队：判断队是否为空 不为空则查看队友、队尾、出队
	cout << "队列大小 = " << q.size() << endl;
	while (!q.empty())
	{
		cout << "队头--姓名：" << q.front().m_Name << "，队尾--年龄：" << q.front().m_Age << endl;
		q.pop(); // 出队
	}
	cout << "队列大小 = " << q.size() << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

STL&list容器

list容器-基本概念：
节点组成：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。
由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。

list的优点：采用动态存储分配，不会造成内存浪费和溢出。链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。
list的缺点：
链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大。
在这里插入图片描述

list容器性质：插入和删除操作都不会造成原有list迭代器的失效，但是在vector容器里是不成立的。
因为vector容器每次做插入和删除操作，都会分配新的容器并复制原容器数据到新容器里，释放原容器。所以迭代器会失效。

list容器-构造函数：

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

案例代码：

#include <list>
void printList(const list<int> &l)
{
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	list<int> lst; // 默认构造
	lst.push_back(10);
	lst.push_back(20);
	lst.push_back(30);
	printList(lst);

	list<int> lst2(lst.begin(), lst.end()); // 区间构造
	printList(lst2);

	list<int> lst3(3, 100); // n个elem构造
	printList(lst3);

	list<int> lst4(lst3); // 拷贝构造
	printList(lst3);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
list容器-赋值和交换：

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

案例代码：

#include <list>
void printList(const list<int> &lst)
{
	for (list<int>::const_iterator it = lst.begin(); it != lst.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	list<int> lst;
	lst.push_back(10);
	lst.push_back(20);
	lst.push_back(30);
	printList(lst);

	list<int> lst2;
	lst2.assign(lst.begin(),lst.end());
	printList(lst2);

	list<int> lst3;
	lst3.assign(3,100);
	printList(lst3);

	list<int> lst4;
	lst4 = lst3;
	printList(lst4);

	list<int> lst5;
	lst5.push_back(30);
	lst5.push_back(20);
	lst5.push_back(10);
	cout << "交换前：" << endl;
	cout << "lst5：";
	printList(lst5);
	cout << "lst：";
	printList(lst);
	lst5.swap(lst);
	cout << "交换后：" << endl;
	cout << "lst5：";
	printList(lst5);
	cout << "lst：";
	printList(lst);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
list容器-大小操作：

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

案例代码：

#include <list>
void printList(const list<int>& lst)
{
	for (list<int>::const_iterator it = lst.begin(); it != lst.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	list<int> lst;
	lst.push_back(10);
	lst.push_back(20);
	lst.push_back(30);
	if (lst.empty())
		cout << "lst为空" << endl;
	else
	{
		cout << "lst不为空" << endl;
		cout << "lst的大小为 = " << lst.size() << endl;
		printList(lst);
	}
	// 重新指定大小
	lst.resize(10,666);
	printList(lst);
	lst.resize(2);
	printList(lst);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
list容器-插入和删除：

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

案例代码：

#include <list>
void printList(const list<int>& lst)
{
	for (list<int>::const_iterator it = lst.begin(); it != lst.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	list<int> lst;
	lst.push_back(10);
	lst.push_back(20);
	lst.push_front(30);
	printList(lst); // 30 10 20

	lst.pop_front(); 
	printList(lst); // 10 20
	lst.pop_back(); 
	printList(lst); // 10

	list<int>::iterator it = lst.begin();
	lst.insert(++it, 20); 
	printList(lst); // 10 20
	lst.insert(it,2,666);
	printList(lst); // 10 20 666 666
	lst.insert(it,lst.begin(),lst.end());
	printList(lst); // 10 20 666 666 || 10 20 666 666
	list<int> lst2 = lst; // 拷贝一份数据备用

	lst.clear();
	printList(lst);
	lst.erase(lst.begin(),lst.end());
	printList(lst);
	lst2.erase(++lst2.begin());
	printList(lst2); // 原数据：10 20 666 666 || 10 20 666 666，抹除后的数据：10 666 666 || 10 20 666 666
	lst2.remove(666);
	printList(lst2); // 原数据：10 666 666 || 10 20 666 666，抹除后的数据：10 || 10 20
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
list容器-数据存取：

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

案例代码：

#include <list>
void printList(const list<int> &lst)
{
	for (list<int>::const_iterator it = lst.begin(); it != lst.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	list<int> lst;
	lst.push_back(10);
	lst.push_back(20);
	lst.push_back(30);
	/* lst[0] 不可以用[]访问list容器中的元素
	   lst.at(0) 不可以用at方式访问list容器中的元素
	   原因是list本质链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的 */
	cout << "第一个元素为：" << lst.front() << endl;
	cout << "最后一个元素为：" << lst.back() << endl;

	// 验证迭代器是不支持随机访问的
	list<int>::iterator it = lst.begin();
	it++; // 支持双向
	it--; 
	//it + 3; // 报错，不支持随机访问
}
int main()
{
	test();
	system("pause");
	return 0;
}

注意：
lst[0] 不可以用[]访问list容器中的元素
lst.at(0) 不可以用at方式访问list容器中的元素
原因是list本质链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的。

输出结果：
在这里插入图片描述
list容器-反转和排序：
案例代码：

#include <list>
#include <algorithm>
void printList(const list<int>& lst)
{
	for (list<int>::const_iterator it = lst.begin(); it != lst.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
bool myCompare(int a, int b) // 回调函数
{
	return (a > b); // 降序，让第一个数 > 第二个数
}
void test()
{
	list<int> lst;
	lst.push_back(20);
	lst.push_back(10);
	lst.push_back(50);
	lst.push_back(40);
	lst.push_back(30);
	printList(lst);

	cout << "反转后：" << endl;
	lst.reverse(); // 反转
	printList(lst);

	// 所有不支持随机访问迭代器的容器，不可以用标准算法
	// 不支持随机访问迭代器的容器，内部会提供对应一些算法
	cout << "排序后（升序）：" << endl;
	//sort(lst.begin(),lst.end()); // 排序
	lst.sort(); // 排序，默认排序规则--升序，从小到大
	printList(lst);

	cout << "排序后（降序）：" << endl;
	lst.sort(myCompare);
	printList(lst);
}
int main()
{
	test();
	system("pause");
	return 0;
}

注意：
所有不支持随机访问迭代器的容器，不可以用标准算法。
不支持随机访问迭代器的容器，内部会提供对应一些算法。例如：sort()函数不适用于list容器。

输出结果：
在这里插入图片描述

STL&set容器

set容器-构造和赋值：

所有元素都会在插入时自动排序。
set/multiset属于关联式容器，底层结构是二叉树实现。

区别：

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

构造：
set< T > st; // 默认构造函数
set(const set &st); // 拷贝构造函数
赋值：
set& operator=(const set &st); // 重载等号操作符

案例代码：

#include <set>
void printSet(const set<int> &s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	set<int> s;
	// 插入数据 只有insert方式
	// set容器特点：所有元素插入时候自动被排序
	// set容器不允许插入重复值，若有重复值则遍历时会被排除多余的重复值
	s.insert(50);
	s.insert(20);
	s.insert(30);
	s.insert(30);
	s.insert(10);
	s.insert(40);
	printSet(s);

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

	set<int> s3 = s2; // 赋值
	printSet(s3);
}
int main()
{
	test();
	system("pause");
	return 0;
}

注意：
1、set容器插入数据只有insert方式。
2、set容器特点：所有元素插入时候自动被排序。
3、set容器不允许插入重复值，若有重复值则遍历时会被排除多余的重复值。

输出结果：
在这里插入图片描述
set容器-大小和交换：

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

案例代码：

#include <set>
void printSet(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void swapSet(set<int>& s1, set<int>& s2)
{
	cout << "交换后：" << endl;
	s1.swap(s2);
	cout << "s1 = ";
	printSet(s1);
	cout << "s2 = ";
	printSet(s2);
}
void test()
{
	set<int> s;
	s.insert(50);
	s.insert(20);
	s.insert(30);
	s.insert(30);
	s.insert(10);
	s.insert(40);
	printSet(s);

	if (s.empty())
		cout << "set容器为空" << endl;
	else
		cout << "set容器大小为：" << s.size() << endl;

	set<int> s2;
	s2.insert(5);
	s2.insert(2);
	s2.insert(3);
	s2.insert(3);
	s2.insert(1);
	s2.insert(4);
	printSet(s2);

	swapSet(s,s2);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
set容器-插入和删除：

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

案例代码：

#include <set>
void printSet(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	set<int> s;
	s.insert(50);
	s.insert(20);
	s.insert(30);
	s.insert(30);
	s.insert(10);
	s.insert(40);
	printSet(s);
	s.erase(++s.begin());
	printSet(s);
	s.erase(50); // 删除重载版本：参数可以为容器内的元素
	printSet(s);
	s.erase(s.begin(),s.end());
	printSet(s);
	s.clear();
	printSet(s);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
set容器-查找和统计：

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

set.end()指向的是容器最后一个元素的后一个位置，回的迭代器并不直接指向 NULL 或者 nullptr。相反，它返回一个特殊的迭代器，识着容器中最后一个元素之后的位置。这是一个逻辑上的边界，而不是实际指向某个具体的内存地址或者 NULL 值。主要用于迭代和容器操作中作为一个边界标志，而不是表示一个具体的元素或者可以解引用的值。

案例代码：

#include <set>
void printSet(const set<int> &s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	set<int> s;
	s.insert(40);
	s.insert(30);
	s.insert(30);
	s.insert(20);
	s.insert(10);
	printSet(s);
	set<int>::const_iterator pos = s.find(30);
	if (pos != s.end())
		cout << "查找到的元素为：" << *pos << endl;
	else
		cout << "未找到该元素" << endl;
	int res = s.count(30);
	cout << "res = " << res << endl; // 对于set容器而言要么返回0要么返回1，因为set容器不插入重复的元素
}
int main()
{
	test();
	system("pause");
	return 0;
}

注意：对于set容器而言要么返回0要么返回1，因为set容器不插入重复的元素。

输出结果：
在这里插入图片描述
set容器-set和multiset区别：

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

案例代码：

#include <set>
/* set.insert返回的是 指向插入位置的迭代器和一个逻辑值，而mulitset.insert仅返回一个逻辑值 */
void printSet(const set<int>& s)
{
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	set<int> s;
	s.insert(40);
	s.insert(30);
	s.insert(30);
	s.insert(20);
	s.insert(10);
	pair<set<int>::iterator, bool> ret = s.insert(50); // pair为对组，简单理解是 包括多个相同或不同返回类型的模板类，<>里就是指定的类型
	if (ret.second)
	{
		cout << "插入当前数据成功" << endl;
		printSet(s);
	}
	else
		cout << "插入失败" << endl;
	ret = s.insert(50); // 因为set容器不允许插入重复数据，因此再次插入相同数据时会提示插入失败
	if (ret.second) // 可以通过 对象.first 或 对象.second 来访问存储的值
	{
		cout << "插入当前数据成功" << endl;
		printSet(s);
	}
	else
		cout << "插入失败" << endl;

	multiset<int> ms;
	ms.insert(10);
	ms.insert(10);
	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

注意：
1、pair为对组，简单理解是包括多个相同或不同返回类型的模板类，<>里就是指定的类型。对组可以通过对象.first 或对象.second 来访问存储的值。
2、set.insert返回的是指向插入位置的迭代器和一个逻辑值，而mulitset.insert仅返回一个逻辑值。
3、因为set容器不允许插入重复数据，因此再次插入相同数据时会提示插入失败。

输出结果：
在这里插入图片描述

STL&pair对组（穿插在set容器里）

pair对组-pair对组的创建：

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

案例代码：

int main()
{
	// 第一种创建方式
	pair<string, int> p1("wjc",23);
	cout << "姓名 = " << p1.first << "，年龄 = " << p1.second << endl;
	// 第二种创建方式
	pair<string, int> p2 = make_pair("hmm",22);
	cout << "姓名 = " << p2.first << "，年龄 = " << p2.second << endl;

	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
set容器-内置类型指定排序规则：
案例代码：

#include <set>
// set容器默认升序排序，利用仿函数 改变排序规则
class myCompare
{
public:
	bool operator()(int v1, int v2) const // 添加const关键字 变成常函数，这样常对象就可以调用
	{
		return (v1 > v2);
	}
};
void printSet(const set<int,myCompare>& s)
{
	for (set<int,myCompare>::const_iterator it = s.begin(); it != s.end(); it++)
		cout << *it << "\t";
	cout << endl;
}
void test()
{
	set<int,myCompare> s;
	s.insert(40);
	s.insert(30);
	s.insert(30);
	s.insert(20);
	s.insert(10);
	printSet(s);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

注意：operator重载运算符的函数必须添加const关键字变成常函数，因为printSet函数里的形参加了const限定为常对象，因此重载运算符的函数必须是常函数，因为常对象只能调用常函数。

set容器-自定义数据类型指定排序规则：
案例代码：

#include <set>
class Person
{
public:
	string m_Name;
	int m_Age;
	Person(string name,int age):m_Name(name),m_Age(age){}
};
class comparePerson
{
public:
	bool operator()(Person p1, Person p2) const // 按照年龄升序规则排序
	{
		return (p1.m_Age < p2.m_Age);
	}
};
void printSet(const set<Person, comparePerson>& s)
{
	for (set<Person, comparePerson>::const_iterator it = s.begin(); it != s.end(); it++)
		cout << "name = " << (*it).m_Name << ",age = " << (*it).m_Age << endl;
}
void test()
{
	Person p1("刘备",24);
	Person p2("关羽", 28);
	Person p3("张飞", 25);
	Person p4("赵云", 21);
	set<Person, comparePerson> s;
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);
	printSet(s);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

STL&map容器

map容器-基本概念：

map中所有元素都是pair。
pair中第一个元素为key（键值），起到索引作用，第二个元素个value（实值）
所有元素都会根据元素的键值自动排序。
map/multimap属于关联式容器，底层结构是二叉树实现。

优点：可以根据key值快速找到value值。
map和multimap区别：
1、map不允许容器中有重复key值元素。
2、multimap允许容器中有重复key值元素。

map容器-构造和赋值：

构造：
map<T1,T2> mp; // map默认构造函数
map(const map &mp); // 拷贝构造函数
赋值：
map& operator=(const map &mp); // 重载等号操作符

案例代码：

#include <map>
void printMap(const map<int,int> &mp)
{
	for (map<int, int>::const_iterator it = mp.begin(); it != mp.end(); it++)
		cout << "key = " << it->first << ",value = " << it->second << endl;
}
void test()
{
	cout << "默认构造：" << endl;
	map<int, int> mp; // 默认构造
	mp.insert(pair<int, int>(2,20));
	mp.insert(pair<int, int>(1, 10));
	mp.insert(pair<int, int>(3,30));
	printMap(mp);

	cout << "拷贝构造：" << endl;
	map<int, int> mp2(mp); // 拷贝构造
	printMap(mp2);

	cout << "赋值：" << endl;
	map<int, int> mp3;
	mp3 = mp2;
	printMap(mp3);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
map容器-大小和交换：

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

案例代码：

#include <map>
void printMap(const map<int, int>& mp)
{
	for (map<int, int>::const_iterator it = mp.begin(); it != mp.end(); it++)
		cout << "key = " << it->first << ",value = " << it->second << endl;
}
void test()
{
	map<int, int> mp;
	mp.insert(pair<int, int>(2, 20));
	mp.insert(pair<int, int>(1, 10));
	mp.insert(pair<int, int>(3, 30));
	if (mp.empty())
		cout << "map容器为空" << endl;
	else
	{
		cout << "map容器不为空" << endl;
		cout << "map.size = " << mp.size() << endl;
		printMap(mp);
	}

	map<int, int> mp2;
	mp2.insert(pair<int,int>(5,50));
	mp2.insert(pair<int, int>(4, 40));
	mp2.insert(pair<int, int>(6, 60));
	cout << "交换前：" << endl;
	cout << "mp = " << endl;
	printMap(mp);
	cout << "mp2 = " << endl;
	printMap(mp2);
	cout << "交换后：" << endl;
	mp.swap(mp2);
	cout << "mp = " << endl;
	printMap(mp);
	cout << "mp2 = " << endl;
	printMap(mp2);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
map容器-插入和删除：

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

案例代码：

#include <map>
void printMap(const map<int, int>& mp)
{
	for (map<int, int>::const_iterator it = mp.begin(); it != mp.end(); it++)
		cout << "key = " << it->first << ",value = " << it->second << endl;
}
void test()
{
	map<int, int> mp;
	mp.insert(pair<int, int>(2, 20)); // 第1种插入方式
	mp.insert(make_pair(1,10)); // 第2种插入方式
	mp.insert(map<int,int>::value_type(3,30)); // 第3种插入方式
	mp[4] = 40; // 第4种插入方式：[]不建议插入，用途：可以利用key访问value
	cout << "mp[5] = " << mp[5] << endl; // 默认key = 5,value = 0
	printMap(mp);

	cout << endl << "erase(key)：" << endl;
	mp.erase(5); // 按照key元素删除
	printMap(mp);

	cout << endl << "erase(pos)：" << endl;
	mp.erase(++mp.begin()); // 删除第二个节点 1 2 3 4 -> 1 3 4
	printMap(mp);

	cout << endl << "erase(beg,end)：" << endl;
	mp.erase(mp.begin(),mp.end());
	printMap(mp);

	cout << endl << "clear()：" << endl;
	mp.clear();
	printMap(mp);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
map容器-查找和统计：

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

案例代码：

#include <map>
void printMap(const map<int, int>& mp)
{
	for (map<int, int>::const_iterator it = mp.begin(); it != mp.end(); it++)
		cout << "key = " << it->first << ",value = " << it->second << endl;
}
void test()
{
	map<int, int> mp;
	mp.insert(pair<int, int>(2, 20)); // 第1种插入方式
	mp.insert(make_pair(1, 10)); // 第2种插入方式
	mp.insert(map<int, int>::value_type(3, 30)); // 第3种插入方式
	mp.insert(pair<int, int>(1, 10));

	map<int, int>::iterator pos = mp.find(1);
	if (pos != mp.end())
		cout << "查找到该元素：key = " << pos->first << ",value = " << pos->second << endl;
	else
		cout << "未查找到该元素" << endl;

	int num = mp.count(1); // map不允许插入重复key元素，count结果要么是0要么是1
	cout << "num = " << num << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述
map容器-内置类型指定排序规则：
案例代码：

#include <map>
// 默认从小到大排序
// 利用仿函数实现从大到小排序
class myCompare
{
public:
	bool operator()(int num1, int num2) const
	{
		return (num1 > num2);
	}
};
void printMap(const map<int, int, myCompare>& mp)
{
	for (map<int, int, myCompare>::const_iterator it = mp.begin(); it != mp.end(); it++)
		cout << "key = " << it->first << ",value = " << it->second << endl;
}
void test()
{
	map<int, int,myCompare> mp;
	mp.insert(pair<int, int>(2, 20)); // 第1种插入方式
	mp.insert(make_pair(1, 10)); // 第2种插入方式
	mp.insert(map<int, int>::value_type(3, 30)); // 第3种插入方式
	mp.insert(pair<int, int>(1, 10));
	printMap(mp);
}
int main()
{
	test();
	system("pause");
	return 0;
}

注意：mp对象在插入数据后会按照升序排序，如果要自定义排序方式需要在mp对象创建时，利用仿函数来自定义排序模式。

输出结果：
在这里插入图片描述
map容器-自定义数据类型指定排序规则：
案例代码：

#include <map>
class Person;
class myCompare
{
public:
	bool operator()(int key1,int key2) const // 按照年龄降序排列
	{
		return (key1 > key2);
	}
};
class Person
{
public:
	string m_Name;
	int m_Age;
	Person() {}
	Person(string name, int age) :m_Name(name), m_Age(age) {}
};
void printMap(const map<int,Person,myCompare> mp)
{
	for (map<int, Person,myCompare>::const_iterator it = mp.begin(); it != mp.end(); it++)
		cout << "key = " << it->first << ",person_name = " << it->second.m_Name << ",person_age = " << it->second.m_Age << endl;
}
void test()
{
	Person p1("孙悟空",97);
	Person p2("猪八戒",95);
	Person p3("唐僧", 100);
	Person p4("沙僧", 91);
	map<int, Person,myCompare> mp;
	mp.insert(make_pair(2, p2));
	mp.insert(pair<int,Person>(1,p1));
	mp[4] = p4;
	mp.insert(map<int,Person>::value_type(3,p3));
	printMap(mp);
}
int main()
{
	test();
	system("pause");
	return 0;
}

输出结果：
在这里插入图片描述

gsd47

关注

5
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
C++ STL 学习总结

STL（标准模板库 standard template library）提供了一系列通用的模板类和函数，用于处理数据。vector存放内置数据类型：案例代码：输出结果：vector存放自定义数据类型：输出结果：vector容器嵌套容器：案例代码：输出结果：vector容器-构造函数：案例代码：输出结果：vector容器-赋值操作：案例代码：输出结果：vector容器-容量和大小：案例代码：输出结果：vector容器-插入和删除：案例代码：输出结果：vector容器-数
复制链接

扫一扫