STL容器集合

迭代器类型

• 注： X 为迭代器类型（如 vector::iterator ，list::iterator ...） ，a和b为迭代器的实际值（如 vector a,b;），n和t为一个整数值， m是该容器的一个成员/成员函数(如  a.begin() )

容器类型				必须满足的条件	表达式
迭代器的基本要求				可复制构造，可复制赋值，可析构	X a(b);     a=b;
				可以递增	++a;      ++b;
随机访问迭代器	双向迭代器	正向迭代器	输入	支持 ==  和 != 的判断	a == b;  a != b;
				支持” * ”，“->” 运算符，但不支持解引赋值(*a = n; //错误)	*a;     a->m;
			输出	支持” * ” 运算符 和 解引赋值(*a = n; )	*a=n;    *(a++) = n;
				可以默认构造	X a;    X b()
				无论是解引还是自增都不影响引用行为	*a; *(a++) = n;
				支持自减	a--;   *(a--);
				支持 ”+”   “-”   ”+=”   “-=”运算符	a += 1; a-=1; a+1; a-1
				支持“”>“   “<”   “>=”   “<=”运算符	a>b a=b a<=b
				支持偏移引用	a[n];  a[0]

容器种类

• 容器概念：具有具体名称（容器，序列容器，关联容器），也就是对容器的一系列要求。

• 容器类型：容器概念的具体化。

• 容器是存储其他对象的对象，

• 有四个没介绍 因为只要会父级就会它

deque ： 双端队列	list:双向链表	forward_list ：单向链表
queue ：队列适配器	priority_queue ：大堆队列适配器	stack ：栈适配器
vector :向量/动态数组	map : 映射/字典	multimap : 多重映射
bitset : 位集	unordered_map :无序映射/字典  和map 差不多只不过是无序的	unordered_multimap 和multimap 差不多只不过是无序的
set ：集合	unordered_set ： 和set 差不多只不过是无序的	unordered_multiset 和set 差不多只不过是无序可以重复的

---

deque

#define

简介：随机访问迭代器

• 可以快速在前后插入元素， 但以前的迭代器将无效，但引用还有效。
• 可以快速删除前后元素    ， 除删除元素的迭代器和引用无效，以前的所以迭代器和引用都有效。

构造函数

• type 为类型(如 int ，char)。n和t为一个整数值。de1,de2,de3....为deque对象

表达式	说明	系统声明
deque  de；	调用默认构造函数，构造de。	deque()
deque  de(n);	构造de, 并指定初始大小为n。	explicit deque(size_type  Count)
deque de(n,t)	构造de, 指定初始大小为n, 初始化所以元素为值为 t	explicit deque(size_type Count ,const type &val)
deque de(de1)	构造de为de1 的副本	deque(const deque &)
dequede(de1.begin(),de1.end())	复制[ de1.begin() ,de1.end()) 区间的值构造的	template deque(InputIterator First, InputIterator Last);
deque de = {n1,n2,n3,n4}	使用初始化列表构造de	deque(initializer_list IList, const Allocator& Al);

成员函数

• type 为类型(如 int ，char)。n和t为一个整数值。de1,de2,de3....为deque对象

表达式	说明
de.assign()	将元素从 deque 中清除并将新的元素序列复制到目标 deque。 支持 de.assign(n,t);  //等价于  deque de(n,t) de.assign(de1.begin() , de1.end); //等价于dequede(de1.begin(),de1.end()) de.assign({1,2,3,4})
de.at(n)	返回对 deque 中指定位置的元素的引用。等价于de[n] 但前者会进行边界检查，抛出 out_of_range 异常
de.back()	返回对 deque 中最后一个元素的引用。
de.begin()	返回对 deque 中第一个元素进行寻址的随机访问迭代器。
de.cbegin()	返回指向 deque 中第一个元素的 const 迭代器。
de.cend()	返回指向刚超出 deque 末尾位置的随机访问 const 迭代器。
de.clear()	清除 deque 的所有元素。
de.crbegin()	返回指向以相反顺序查看的 deque 中的第一个元素的随机访问 const 迭代器。
de.crend()	返回指向以相反顺序查看的 deque 中的第一个元素的随机访问 const 迭代器。
de.emplace()	将就地构造的元素插入到指定位置的 deque 中。 支持 de.emplace(de.begin(),n)      //它的速度更快 //将 n 插入到 de.begin()的前面 等价于 de.push_front(n); de.insert(de.begin(),n); de.emplace(de.begin(),move(de1)); //将de1 移动插入到de.begin()的前面， 插入后de1 为空
de.emplace_back(n)	将就地构造的元素n添加到 deque 的末尾。速度比de.push_back()快
de.empalcce_front(n)	将就地构造的元素n添加到 deque 的开头。
de.empty()	如果 deque 包含零个元素，则返回 true；如果它包含一个或多个元素，则返回 false。
de.end()	返回指向刚超出 deque 末尾位置的随机访问迭代器。
de.erase()	从指定位置删除 deque 中一个或一系列元素。 支持 de.erase(de.begin()+1)   //删除  de.begin()+1 迭代器的元素，也就是删除第二个元素 de.erase(de.begin(),de.end() - 1) // 删除区间 [de.begin(),de.end() - 1))  的元素
de.front()	返回对 deque 中第一个元素的引用。
de.get_allocator()	返回用于构造 allocator 的 deque 对象的副本。
de.insert()	将一个、多个或一系列元素插入到指定位置的 deque 中。 支持 de.insert(de.begin() , n);   //在de.begin(),的前面插入 n de.insert(de.end(),n,t);        //在de.end() 的 前面插入n 个 t de.insert(de.end(), de2.begin() ,de2.end()) // 将区间 [ de2.begin() ,de2.end() ) 的元素复制插入到 de.end() 的前面。 de.insert(de.end(),{n1,n2,n3}) //在de.end() 的 前面插入{n1,n2,n3}
de.max_size()	返回 deque 的最大可取长度。
de.pop_back()	清除 deque 末尾处的元素。
de.pop_front()	清除 deque 开头处的元素。
de.push_back()	将元素添加到 deque 的末尾。
de.push_front()	将元素添加到 deque 的开头。
de.rbegin()	返回指向反向 deque 中的第一个元素的随机访问迭代器。
de.rend()	返回指向刚超出反向 deque 中的最后一个元素位置的随机访问迭代器。
de.resize(n)	为 deque 指定新的大小为 n 。
de.shrink_to_fit()	放弃额外容量。
de.size()	返回 deque 中的元素数量。
de.swzp(de2)	交换两个 deque 的元素。

list

#define

简介：双向迭代器

•    可以快速插入元素到任何位置，本且不会影响原来的 引用 / 迭代器
•    但是不支持随机访问

• type 为类型(如 int ，char)。n和t为一个整数值。de1,de2,de3.为list对象

构造函数

成员函数

名称	描述
de.assign()	将元素从 list 中清除并将新的元素序列复制到目标 list。 支持 de.assign(n,t);  //等价于  list de(n,t) de.assign(de1.begin() , de1.end); //等价于listde(de1.begin(),de1.end()) de.assign({1,2,3,4})
de.back()	返回对列表中最后一个元素的引用。
de.begin()	返回发现列表中第一个元素的位置的迭代器。
de.cbegin()	返回发现列表中第一个元素的位置的常量迭代器。
de.cend()	返回发现一个列表中最后一个元素之后的位置的敞亮表达式。
de.clear()	消除列表中的全部元素。
de.crbegin()	返回发现反向列表中第一个元素的位置的常量迭代器。
de.crend()	返回用于发现反向列表中最后一个元素之后的位置的常量迭代器。
de.emplace()	将就地构造的元素插入到指定位置的 list 中。 支持 de.emplace(de.begin(),n)      //它的速度更快 //将 n 插入到 de.begin()的前面 等价于 de.push_front(n); de.insert(de.begin(),n); de.emplace(de.begin(),move(de1)); //将de1 移动插入到de.begin()的前面， 插入后de1 为空
de.emplace_back(n)	将就地构造的元素n添加到 list 的末尾。速度比de.push_back()快
de.empalcce_front(n)	将就地构造的元素n添加到 list 的开头。
de.empty()	如果 list 包含零个元素，则返回 true；如果它包含一个或多个元素，则返回 false。
de.end()	返回用于发现列表中最后一个元素之后的位置的迭代器。
de.erase()	从指定位置删除 list 中一个或一系列元素。 支持 de.erase(de.begin()+1)   //删除  de.begin()+1 迭代器的元素，也就是删除第二个元素 de.erase(de.begin(),de.end() - 1) // 删除区间 [de.begin(),de.end() - 1))  的元素
de.front()	返回对列表中第一个元素的引用。
de.get_alloctor()	返回用于构造列表的 allocator 对象的一个副本。
de.insert()	将一个、多个或一系列元素插入到指定位置的 list 中。 支持 de.insert(de.begin() , n);   //在de.begin(),的前面插入 n de.insert(de.end(),n,t);        //在de.end() 的 前面插入n 个 t de.insert(de.end(), de2.begin() ,de2.end()) // 将区间 [ de2.begin() ,de2.end() ) 的元素复制插入到 de.end() 的前面。 de.insert(de.end(),{n1,n2,n3}) //在de.end() 的 前面插入{n1,n2,n3}
de.max_size()	返回列表的最大长度。
de.merge()	将元素从参数列表移除，将它们插入目标列表，将新的组合元素集以升序或其他指定顺序排序。 支持 de和de2 已经排好序 de.merge(de2);  //以升序合并到de，合并后de2为空 de.merge(de2, M);  //以自定义M序合并到de，合并后de2为空 M:可以是谓词。 M:可以是std::greater() 降序方式 M:可以是std::less()     升序方式
de.pop_back()	删除列表末尾的元素。
de.pop_front()	删除列表起始处的一个元素。
de.push_back()	在列表的末尾添加元素。
de.push_front()	在列表的开头添加元素。
de.rbegin()	返回发现反向列表中第一个元素的位置的迭代器。
de.remove(n)	清除列表中与指定值n匹配的元素。
de.remove_if(谓词)	将满足指定谓词的元素从列表中消除。 谓词是什么， emmm 太长了不说   在后面自己看
de.rend()	返回发现反向列表中最后一个元素之后的位置的迭代器。
de.resize()	为列表指定新的大小。
de.reverse()	反转列表中元素的顺序。
de.size()	返回列表中元素的数目。
de.sort()	按升序或其他顺序关系排列列表中的元素。 支持 de.sort(); //以升序排序 de.sort(M);  //以自定义M序排序 M:可以是谓词。 M:可以是std::greater() 降序方式 M:可以是std::less()     升序方式
be.splice()	将元素从自变量列表中删除并将它们插入目标列表。 支持 where:是一个该类型的 迭代器如(de.begin()) be.splice(where,be2); //将be2 整个插入到where的前面 插入后be2为空 be.splice(where,be2,be2.begin());//将be2的 be2.begin()元素插入where 的前面。
be.swap(b2)	交换两个列表的元素。
be.unique()	从列表中删除满足某些其他二元谓词的相邻重复元素或相邻元素。

forward_list

简介：单向迭代器

•    可以快速插入元素到任何位置，本且不会影响原来的 引用 / 迭代器
•    但是不支持随机访问， 本且只可以 向后移动
• type 为类型(如 int ，char)。n和t为一个整数值。de1,de2,de3....为forward_list对象

构造函数

成员函数

名称	描述
de.assign()	清除转发列表中的元素，并将一组新的元素复制到目标转发列表。 支持 de.assign(n,t);  //等价于  list de(n,t) de.assign(de1.begin() , de1.end); //等价于listde(de1.begin(),de1.end()) de.assign({1,2,3,4})
de.before_begin()	返回寻址转发列表中第一个元素之前的位置的迭代器。
de.begin()	返回寻址转发列表中第一个元素的迭代器。
de.cbefore_begin()	返回寻址转发列表中第一个元素之前的位置的常量迭代器。
de.cbegin()	返回寻址转发列表中第一个元素的常量迭代器。
de.cend()	返回寻址转发列表中最后一个元素之后的位置的常量迭代器。
de.clear()	清除转发列表中的所有元素。
de.emplace_after()	在指定位置之后移动构造新元素。 de.emplace(de.begin(),n) //在de.begin()的后面移动插入n元素
de.emplace_front(n)	在列表的起始位置添加一个就地构造的n元素。
de.empty()	测试转发列表是否为空。
de.end()	返回寻址转发列表中最后一个元素之后的位置的迭代器。
de.erase()	删除转发列表中指定位置之后的元素。 de.erase(de.bgein())  //删除de.begin()的后面的元素
de.front()	返回对转发列表中第一个元素的引用。
de.get_allocator()	返回用于构造转发列表的分配器对象的一个副本。
de.insert_after()	在转发列表中的指定位置之后添加元素。 支持 de.insert_after(de.begin() , n);   //在de.begin(),的后面插入 n de.insert_after(de.begin(),n,t);        //在de.end() 的 后面插入n 个 t de.insert_after(de.begin(),de2.begin() ,de2.end()) // 将区间 [ de2.begin() ,de2.end() ) 的元素复制插入到 de.begin() 的后面。
de.max_size()	返回转发列表的最大长度。
de.merge()	将元素从参数列表中删除，将它们插入目标转发列表，将新的组合素集以升序或其他指定顺序排序。 支持 de和de2 已经排好序 de.merge(de2);  //以升序合并到de，合并后de2为空 de.merge(de2, M);  //以自定义M序合并到de，合并后de2为空 M:可以是谓词。 M:可以是std::greater() 降序方式 M:可以是std::less()     升序方式
de.pop_front()	删除转发列表起始处的一个元素。
de.push_front()	在转发列表起始处添加一个元素。
de.remove(n)	清除转发列表中与指定值n匹配的元素。
de.remove_if(谓词)	将满足指定谓词的元素从转发列表中清除。 谓词是什么， emmm 太长了不说 在后面自己看
de.resize()	为转发列表指定新的大小。
de.reverse()	颠倒转发列表中元素的顺序。
de.sort()	按升序或按谓词指定的顺序排列元素。 支持 de.sort(); //以升序排序 de.sort(M);  //以自定义M序排序 M:可以是谓词。 M:可以是std::greater() 降序方式 M:可以是std::less()     升序方式
de.splice_after()	重新联结节点间的链接。 支持 where:是一个该类型的 迭代器如(de.begin()) be.splice_after(where,be2); //将be2 整个插入到where的后面 插入后be2为空 be.splice_after(where,be2,be2.begin());//将be2的 be2.begin()元素插入where 的后面。
de.swap(de2)	交换两个转发列表的元素。
de.unique()	删除通过了指定测试的相邻元素。

 queue

简介：它提供功能的限制，限制对一些基本容器类型的前端和后端元素的访问权限。 可以在后端添加或从前端移除元素，并且可以在 queue 的任何一端检查元素。

• 默认使用的容器是deque() 双端队列，可以指定其容器当容器支持front、back、push_back 和 pop_front 操作
• 支持先进先出 (FIFO) 数据结构。
• type 为类型(如 int ，char)。n和t为一个整数值。de1,de2,de3....为queue对象

构造函数

表达式	说明	系统声明
queue de;	调用默认构造函数，但不可以queue de()	queue();
queue de(de2)	构造de为de2 的副本	explicit queue(const queue&);
queue de({n1,n2,n3})	调用指定容器的构造函数。	explicit queue( const Container& cont = Container() );

成员函数

名称	描述
de.back()	返回对在 queue 后部最后一个元素的引用。
de.empty()	测试 queue 是否为空。
de.front()	返回对 queue 前部的第一个元素的引用。
de.pop()	从 queue 前端移除一个元素。
de.push(n)	将元素n添加到 queue 的后部。
de.emplace(n)	将元素n移动构造到 queue 的后部。和de.push(n) 一样但是它快一些 这个并不常用，甚至有些文档都没有提起。
de.size()	返回 queue 中的元素数量。

priority_queue

简介：一个模板容器适配器类，它提供功能的限制，限制一些基本容器类型顶端元素的访问权限，并且该类通常为最大类或具有最高优先级。 可以将新元素添加到 priority_queue，并且可以检查或删除 priority_queue 的顶级元素。

• 默认使用vector 容器 ，也可以指定容器，但容器必须支持 front、push_back 和 pop_back 的操作和随机访问迭代器的其他序列容器。
• 对queue ：队列适配器 的进一步限制，让其最大/最小元素放在顶部（其余元素不一定是有序的）。
• 可以实现大堆/小堆  默认大堆。

构造函数

表达式	说明	系统声明
priority_queue de;	调用默认构造函数，但不可以queue de()	queue();
priority_queue de(de2)	构造de为de2 的副本	explicit priorityqueue(const  priority_queue&);
priority_queue de(u.begin(),u.end())	复制构造区间[de2.begin(),de2.end())  的元素构造de 注意这里u 可以说任何满足其具有begin(),end()迭代器的容器	template priority_queue(InputIterator first, InputIterator last);

后面的构造函可能有点复杂 

定义：

template , class Compare= less >
class priority_queue

Type
要在 priority_queue 中存储的元素数据类型。

Container
用来实现 priority_queue 的基础容器的类型。

Compare
一种提供函数对象的类型，该函数对象可将两个元素值作为排序键进行比较，以确定其在 priority_queue 中的相对顺序。 此参数为可选自变量，默认值是二元谓词 less。

注意：

     在第一个定义中，cmp2是一个类，重载了()运算符，用于比较两个元素的大小。因此，在priority_queue的定义中，将cmp2作为类型传入即可，不需要额外使用(cmp2)。

    而在第二个定义中，cmp是一个匿名的 lambda 表达式，用于比较两个元素的大小。由于 lambda 表达式没有具体的类型，所以需要通过decltype(cmp)来获取其类型，并将其作为比较器传入priority_queue的定义中，所以需要额外使用(cmp)。

#include
#include
#include
class cmp2
{
public:
    bool operator()(int a, int b) const { return a > b; }

};

int main()
{
    using namespace std;
    auto cmp = [](int a,int b){return a>b;};
    { 
        priority_queue,cmp2> de; 
    }  //采用小堆形式（小的在 de.top() 处）
     
    {
        priority_queue,decltype(cmp)> de(cmp);
    }   //采用小堆形式（向的在 de.top() 处）
    
    {
        vector nums = {1,5,3,2,4};
        priority_queue> de(nums.begin(),nums.end());  
    }//采用大堆（默认）

    {
        vector nums = {1,5,3,2,4};
        priority_queue,cmp2> de(nums.begin(),nums.end());  
        或者
        priority_queue,decltype(cmp)> de(nums.begin(),nums.end(),cmp);
    }//采用小堆
return 0;
}

成员函数

成员函数	说明
de.empty()	测试 priority_queue 是否为空。
de.pop()	从顶部位置移除 priority_queue 的最大元素。
de.push(n) / de.emplace(n)	基于来自 operator< 的n元素的优先级将元素添加到优先级队列。
de.size()	返回 priority_queue 中的元素数量。
de.swap(de2)	交换de和de2 的元素
de.top()	返回对 priority_queue 顶部的最大元素的常量引用。

stack

简介：一种模板容器适配器类，它提供了功能的限制，限制对最近添加到某些基础容器类型的元素的访问。

• stack 是一种先进后出 (LIFO) 数据结构。
• 默认使用deque<>容器，也可以自定义任何其他支持 back、push_back 和 pop_back 操作的序列容器。
• type 为类型(如 int ，char)。n和t为一个整数值。de1,de2,de3....为stack对象。

构造函数

表达式	说明	系统声明
stack de;	调用默认构造函数，但不可以stack de()	stack();
stack de(de2)	调用复制构造函数	stack(const stack& other);
stack de({n1,n2,n3})	调用指定容器的构造函数。	explicit stack( const Container& cont);

成员函数

名称	描述
de.empty()	测试 stack 是否为空。
de.pop()	从 stack 的顶部删除元素。
de.push(n) / de.emplace(n)	将元素n添加到 stack 顶部。后者快一些。
de.size()	返回 stack 中的元素数量。
de.swap(de2)	交换de和de2 的元素
de.top()	返回对 stack 顶部元素的引用。

vector

简介：是一个向量容器按照线型方式存储，支持随机访问迭代器。

• 支持随机插入元素，但是除了在最后一个位置插入元素是O(1)  级别，其它都是O(n)。
• 当插入元素/矢量从新分配时，将导致以前的迭代器和引用无效化（当在前面插入元素时，后面的的元素统一向后移动给新元素腾位置。前提是矢量未新分配时）。
• type 为类型(如 int ，char)。n和t为一个整数值。de1,de2,de3....为vector对象

构造函数

成员函数

名称	描述
de.assign()	清除矢量并将指定的元素复制到该空矢量。
de.at()	返回对矢量中指定位置的元素的引用。
de.back()	返回对向量中最后一个元素的引用。
de.begin()	对该向量中第一个元素返回随机访问迭代器。
de.capacity()	返回在不分配更多的存储的情况下向量可以包含的元素数。
de.cbegin()	返回指向向量中第一个元素的随机访问常量迭代器。
de.cend()	返回一个随机访问常量迭代器，它指向刚超过矢量末尾的位置。
de.crbegin()	返回一个指向反向矢量中第一个元素的常量迭代器。
de.crend()	返回一个指向反向矢量末尾的常量迭代器。
de.clear()	清除向量的元素。
de.data()	返回指向向量中第一个元素的指针。
de.emplace()	将就地构造的元素插入到指定位置的向量中。 支持 de.emplace(de.begin(),n); //将元素n插入到de.begin()的前面 de.emplace(de.begin(),de2.begin(),de.end()) //将区间[de2.begin(),de.end())的元素插入到de.begin()，的前面
de.emplace_bace(n)	将一个就地构造的n元素添加到向量末尾。
de.empty()	测试矢量容器是否为空。
de.end()	返回指向矢量末尾的随机访问迭代器。
de.erase()	从指定位置删除向量中的一个元素或一系列元素。 支持 de.erase(de.begin()); //删除de.begin() 迭代器所指向的元素 de.erase(de.begin(),de.end()); //删除[(de.begin(),de.end()) 区间的元素
de.front()	返回对向量中第一个元素的引用。
de.get_allocator()	将对象返回到矢量使用的 allocator 类。
de.insert()	将一个元素或多个元素插入到指定位置的向量中。 支持 de.insert(de.begin(),n); //将元素n插入到de.begin()的前面 de.insert(de.begin(),de2.begin(),de.end()) //将区间[de2.begin(),de.end())的元素插入到de.begin()，的前面
de.max_size()	返回向量的最大长度。
de.pop_back()	删除矢量末尾处的元素。
de.push_back(n)	在矢量末尾处添加一个元素n。
de.rbegin()	返回指向反向向量中第一个元素的迭代器。
de.rend()	返回一个指向反向矢量末尾的迭代器。
de.reserve()	保留向量对象的最小存储长度。
de.resize(n)	为矢量指定新的大小为n。
de.shrink_to_fit()	放弃额外容量。
de.size()	返回向量中的元素数量。
de.swap(de2)	交换两个向量的元素。

map

简介：

• 用于存储和检索集合中的数据，此集合中的每个元素均为包含数据值和排序键的元素对。 键的值是唯一的，用于自动排序数据。
• 可以直接更改映射中的元素值。 键值是常量，不能更改。 必须先删除与旧元素关联的键值，才能为新元素插入新键值。

• 大小可变的关联容器，基于关联键值高效检索元素值。

• 可逆，因为它提供双向迭代器来访问其元素。

• 有序，因为它的元素根据指定的比较函数按键值排序。

• 唯一。 因为它的每个元素必须具有唯一键。

• 关联容器对，因为它的元素数据值与其键值不同。

• 为双向迭代器。

• keyt:键数据类型。valt: 存储的元素数据类型。de,de1,de2为map对象。kn,为键值，vn为元素值；

构造函数

成员函数

成员函数	说明
de.at(kn)	查找具有指定键值的元素。等价于de[kn]
de.begin()	返回一个迭代器，此迭代器指向 map 中的第一个元素。
de.cbegin()	返回一个常量迭代器，此迭代器指向 map 中的第一个元素。
de.cend()	返回一个超过末尾常量迭代器。
de.clear()	清除 map 的所有元素。
de.contains(kn)	c++20新增检查 map 中是否包含具有kn键的元素。
de.count(kn)	返回映射中kn键与参数中指定的键匹配的元素数量。map是单映射所以 只可能是0 / 1.  multimap多重映射的时候才有意义
de.crbegin()	返回一个常量迭代器，此迭代器指向反向 map 中的第一个元素。
de.crend()	返回一个常量迭代器，此迭代器指向反向 map 中最后一个元素之后的位置。
de.emplace(kn,vn)	将就地构造的键值对{kn,vn}插入到 map。
de.emplace_hint()	将就地构造的键值对{kn,vn}插入到 map。附带位置提示。 如 de.emplace_hint(de.begin(),kn,vn); //插入键值对{kn,vn}到de.begin(),的位置 //不推荐这么使用，但不能不知道
de.empty()	如果 map 为空，则返回 true。
de.end()	返回超过末尾迭代器。
de.equal_range()	返回一对迭代器。返回std::pair<… ::iterator,… ::iterator> 对象 第一个迭代器指向大于等于kn这个键值的第一个元素 等价于lower_bound(); 第二个迭代器指向大于kn这个键值的第一个元素 等价于upper_bound();
de.erase()	从指定位置移除映射中的元素或元素范围。 支持 de.erase(de.begin()); //移除de.begin() 指向的键值对 de.erase(de.begin(),de.end()) //移除区间[de.begin(),de.end())的键值对 de.erase(kn); //移除键值为kn的键值对。
de.find(kn)	返回指向键值为kn的迭代器。
de.get_allocator()	返回用于构造 allocator 的 map 对象的副本。
de.insert()	将一个或一系列元素插入到 map 中的指定位置。 支持 de.insert(std::make_pair(12,45));  //插入一个键值对 de.insert(de2.begin(), de2.end()); //将区间[de2.begin(),de2.end ) 复制插入到de de.insert({ {1,2},{4,6} }); //插入{ {1,2},{4,6} } 这些键值对 de.insert(de.begin(), { 1,2 }); //在de.begin()，处插入键值对，不推荐这么使用，但不能不知道
de.key_comp()	返回用于对 map 中的键进行排序的比较对象副本。
de.lower_bound(kn)	返回第一个>= kn 键值的迭代器
de.max_size()	返回 map 的最大长度。
de.rbegin()	返回一个迭代器，此迭代器指向反向 map 中的第一个元素。
de.rend()	返回一个迭代器，此迭代器指向反向 map 中最后一个元素之后的位置。
de.size()	返回 map 中的元素数量。
de.swap(de2)	交换两个映射的元素。
de.upper_bound()	返回第一个>= kn 键值的迭代器
de.value_comp()	检索用于对 map 中的元素值进行排序的比较对象副本。

multimap

简介：C++ 标准库 multimap 类用于存储和检索集合中的数据，此集合中的每个元素均为包含数据值和排序键的元素对。 键值不需要唯一。可以直接更改元素值，但不能直接更改键值。

• 大小可变的关联容器，支持基于关联键值高效检索元素值。

• 可逆，因为它提供双向迭代器来访问其元素。

• 有序，因为它的元素在容器中根据指定的比较函数按键值排序。

• 多个，它的元素不需要具有唯一键，因此一个键值可具有多个相关联的元素数据值，且数据值不会去重。

• 关联容器对，因为它的元素数据值与其键值不同。

• keyt:键数据类型。valt: 存储的元素数据类型。de,de1,de2为multimap对象。kn,为键值，vn为元素值。

 构造函数

成员函数

成员函数	说明
de.begin()	返回一个迭代器，此迭代器指向 multimap 中的第一个元素。
de.cbegin()	返回一个常量迭代器，此迭代器指向 multimap 中的第一个元素。
de.cend()	返回一个超过末尾常量迭代器。
de.clear()	清除 multimap 的所有元素。
de.contains(kn)	c++20新增检查 multimap 中是否包含具有kn键的元素。
de.count(kn)	返回映射中kn键与参数中指定的键匹配的元素数量。multimap是单映射所以 只可能是0 / 1.  multimultimap多重映射的时候才有意义
de.crbegin()	返回一个常量迭代器，此迭代器指向反向 multimap 中的第一个元素。
de.crend()	返回一个常量迭代器，此迭代器指向反向 multimap 中最后一个元素之后的位置。
de.emplace(kn,vn)	将就地构造的键值对{kn,vn}插入到 multimap。
de.emplace_hint()	将就地构造的键值对{kn,vn}插入到 multimap。附带位置提示。 如 de.emplace_hint(de.begin(),kn,vn); //插入键值对{kn,vn}到de.begin(),的位置 //不推荐这么使用，但不能不知道
de.empty()	如果 multimap 为空，则返回 true。
de.end()	返回超过末尾迭代器。
de.equal_range()	返回一对迭代器。返回std::pair<… ::iterator,… ::iterator> 对象 第一个迭代器指向大于等于kn这个键值的第一个元素 等价于lower_bound(); 第二个迭代器指向大于kn这个键值的第一个元素 等价于upper_bound();
de.erase()	从指定位置移除映射中的元素或元素范围。 支持 de.erase(de.begin()); //移除de.begin() 指向的键值对 de.erase(de.begin(),de.end()) //移除区间[de.begin(),de.end())的键值对 de.erase(kn); //移除键值为kn的键值对。
de.find(kn)	返回指向键值为kn的迭代器。
de.get_allocator()	返回用于构造 allocator 的 multimap 对象的副本。
de.insert()	将一个或一系列元素插入到 multimap 中的指定位置。 支持 de.insert(std::make_pair(12,45));  //插入一个键值对 de.insert(de2.begin(), de2.end()); //将区间[de2.begin(),de2.end ) 复制插入到de de.insert({ {1,2},{4,6} }); //插入{ {1,2},{4,6} } 这些键值对 de.insert(de.begin(), { 1,2 }); //在de.begin()，处插入键值对，不推荐这么使用，但不能不知道
de.key_comp()	返回用于对 multimap 中的键进行排序的比较对象副本。
de.lower_bound(kn)	返回第一个>= kn 键值的迭代器
de.max_size()	返回 multimap 的最大长度。
de.rbegin()	返回一个迭代器，此迭代器指向反向 multimap 中的第一个元素。
de.rend()	返回一个迭代器，此迭代器指向反向 multimap 中最后一个元素之后的位置。
de.size()	返回 multimap 中的元素数量。
de.swap(de2)	交换两个映射的元素。
de.upper_bound()	返回第一个>= kn 键值的迭代器
de.value_comp()	检索用于对 multimap 中的元素值进行排序的比较对象副本。

bitset

简介：在 C++ 标准库中，std::bitset 被分类为“位集合类”而非传统意义上的容器。它对位级高效管理。

• size:通俗的说是占己位 可以是1 2  3， n位值;

构造函数

成员函数

名称	描述
de.all()	所有位为1 返回 true 否则返回false
de.any()	至少有一位为1 返回 true 否则返回false
de.count()	返回位为1的个数
de.flip()	反转 bitset 中的所有位的值或反转位于指定位置的单个位。 支持 de.flip();  //所有位，1变0 ，0变1 de.flip(n); //反转第n位
de.none()	所有位为0 返回 true 否则返回false
de.reset()	将 bitset 中的所有位重置为 0 或将位于指定位置的位重置为 0。 支持 de.reset();  //所位重置为0 de.reset(n); //第n位重置为0
de.set()	将 bitset 中的所有位设置为 1 或将位于指定位置的位设置为 1。 支持 de.set();  //所位重置为1 de.set(n); //第n位重置为1 de.set(n,0); //第n位重置为0
de.size()	返回 bitset 对象中的位数。
de.test()	测试 bitset 中指定位置处的位是否设置为 1。 de.test(n); //第n位为1 返 true 否则返回 false
de.to_string()	将 bitset 对象转换为字符串表示形式。
de.to_ullong()	将 bitset 中的位值的总和作为 unsigned long long 返回。
de.to_ulong()	将 bitset 对象转换为 unsigned long，如果将后者用于初始化 bitset，则会产生包含的位的序列。

运算符重载

除了比较运算符其的都重载了。

set

简介：有序并且去重的容器。

• 可逆，因为它提供双向迭代器来访问其元素。

• 有序，因为它的元素在容器中根据指定的比较函数按键值排序。

• 唯一，每个元素必须具有唯一键。 集还是简单关联容器，因此它的元素也是唯一的。

• type 为类型(如 int ，char)。n和t为一个整数值。de1,de2,de3....为set对象。

构造函数

成员函数

名称	描述
de.begin()	返回一个迭代器，此迭代器用于发现 set 中的第一个元素。
de.cbegin()	返回一个常量迭代器，此迭代器用于发现 set 中的第一个元素。
de.cend()	返回一个常量迭代器，此迭代器用于发现 set 中最后一个元素之后的位置。
de.clear()	清除 set 的所有元素。
de.contains()	c++20 新增 检查 set 中是否包含具有指定键的元素。
de.count()	返回 set 中其键与指定为参数的键匹配的元素数量。
de.crbegin()	返回一个常量迭代器，此迭代器用于发现反向 set 中的第一个元素。
de.crend()	返回一个常量迭代器，此迭代器用于发现反向 set 中最后一个元素之后的位置。
de.emplace(n)	将就地构造的元素n插入到 set。
de.emplace_hint()	将就地构造的元素插入到 set，附带位置提示。 de.emplace(de.begin(),n); //在de.begin() ,处插入n 如果n 导致错序可能程序崩溃
de.empty()	测试 set 是否为空。
de.end()	返回一个迭代器，此迭代器用于发现 set 中最后一个元素之后的位置。
de.equal_range()	返回一对迭代器。返回std::set<… ::iterator,… ::iterator> 对象 第一个迭代器指向大于等于kn这个键值的第一个元素 等价于lower_bound(); 第二个迭代器指向大于kn这个键值的第一个元素 等价于upper_bound();
de.erase()	删除指定位置的元素或元素范围。 支持 de.erase(de.begin()); //移除de.begin() 指向的值 de.erase(de.begin(),de.end()) //移除区间[de.begin(),de.end())指向的值 de.erase(n); //移除指值为n的元素。
de.find(n)	返回指向键值为kn的迭代器。
de.get_allocator()	返回用于构造 allocator 的 set 对象的副本。
de.insert()	将一个或一系列元素插入到 set 中的指定位置。 支持 de.insert(n);  //插入一个n de.insert(de2.begin(), de2.end()); //将区间[de2.begin(),de2.end ) 复制插入到de de.insert({n1,n2,n3}); //插入{ n1,n2,n3 } de.insert(de.begin(), n); //在de.begin()，处插入n，不推荐这么使用，但不能不知道
de.key_comp()	检索用于对 set 中的键进行排序的比较对象副本。
de.lower_bound(n)	返回第一个>= n 键值的迭代器
de.max_size()	返回 set 的最大长度。
de.rbegin()	返回一个迭代器，此迭代器用于发现反向 set 中的第一个元素。
de.rend()	返回一个迭代器，此迭代器用于发现反向 set 中最后一个元素之后的位置。
de.size()	返回 set 中的元素数量。
de.swap(de2)	交换两个 set 的元素。
de.upper_bound()	返回第一个> kn 键值的迭代器
de.value_comp()	检索用于对 set 中的元素值进行排序的比较对象副本。

谓词

简介：在计算机编程中，谓词是指一种可以返回真或假值的函数或者函数对象。

• 谓词可以是函数指针、函数对象，或者是 lambda 表达式，只要满足可以调用并返回布尔值的条件即可。
• 谓词根据传参个数分为  一元谓词(一个参数)  二元谓词（二个参数）  三元谓词 （...）

      

#include
#include

/*
本来不想写说明的，因为光是STL的容器集合就非常繁多了 ^_^ 。
但后面发现
还是要写因为用到的地方还是蛮多的。
*/


// 谓词说的高大上，其实就是 一种提供比较方式的方法

/*
      auto cmp = [](int a,int b)->bool{return a cmp2 = [](int a,int b)->bool{return atype 
      //返回类型
       
      {函数体} 

*/

int main()  //谓词就是干这个的
{
      int nums[10] = {3,5,6,2,1,45,21,0,12,21};
      
      //排序函数 默认升序 可我叛逆不想要升序
      std::sort(nums,nums+10);


      std::sort(nums,nums+10,[](int a,int b)->bool{return a>b;});
      /*a>b; 前面的大于后面的，所以是降序*/

      std::sort(nums, nums + 10, [](int a, int b)->bool {return (a % 2) < (b % 2); });
     //偶数排前面

}


/*
它还可以是函数
bool ap(int a,int b){return a