STL 容器适配器用法

一、stack

栈中存储的元素满足后进先出（简称LIFO）
stack 适配器的开头端通常称为栈顶。
每次只能访问适配器中位于最顶端的元素，也只有移除 stack 顶部的元素之后，才能访问位于栈中的元素

#include <stack>
using namespace std;

stack<T,Container=deque> 模板类提供了 2 个参数，通过指定第二个模板类型参数
只要该容器支持 empty()、size()、back()、push_back()、pop_back() 这 5 个成员函数即可
序列式容器中同时包含这 5 个成员函数的，有 vector、deque 和 list 这 3 个容器。
因此，stack 适配器的基础容器可以是它们 3 个中任何一个

初始化
1）可以用一个基础容器来初始化 stack 适配器

std::list<int> values {1, 2, 3};
std::stack<int,std::list<int>> my_stack (values);

2. 还可以用一个 stack 适配器来初始化另一个 stack 适配器

std::list<int> values{ 1, 2, 3 };
std::stack<int, std::list<int>> my_stack1(values);
std::stack<int, std::list<int>> my_stack=my_stack1;
//std::stack<int, std::list<int>> my_stack(my_stack1);

成员函数 功能
empty()
当 stack 栈中没有元素时，该成员函数返回 true；反之，返回 false。
size()
返回 stack 栈中存储元素的个数。
top()
返回一个栈顶元素的引用，类型为 T&。如果栈为空，程序会报错。
push(const T& val)
先复制 val，再将 val 副本压入栈顶。这是通过调用底层容器的 push_back() 函数完成的。
push(T&& obj)
以移动元素的方式将其压入栈顶。这是通过调用底层容器的有右值引用参数的 push_back() 函数完成的。
pop()
弹出栈顶元素。
emplace(arg…)
arg… 可以是一个参数，也可以是多个参数，但它们都只用于构造一个对象，并在栈顶直接生成该对象，作为新的栈顶元素。
swap(stack & other_stack)
将两个 stack 适配器中的元素进行互换，需要注意的是，进行互换的 2 个 stack 适配器中存储的元素类型以及底层采用的基础容器类型，都必须相同。

二、queue

在创建该容器之前，程序中应包含以下 2 行代码：

#include <queue>
using namespace std;

最先进入 queue 的元素，也可以最先从 queue 中出来，即用此容器适配器存储数据具有“先进先出（简称 “FIFO” ）”的特点，因此 queue 又称为队列适配器。

作为 queue 容器适配器的基础容器，其必须提供 front()、back()、push_back()、pop_front()、empty() 和 size() 这几个成员函数，符合条件的序列式容器仅有 deque 和 list。

初始化

1. 可以用基础容器来初始化 queue 容器适配器，只要它们存储的元素类型以及底层采用的基础容器类型相同即可

std::deque<int> values{1,2,3};
std::queue<int> my_queue(values);

2. 还可以直接通过 queue 容器适配器来初始化另一个 queue 容器适配器，只要它们存储的元素类型以及底层采用的基础容器类型相同即可

std::deque<int> values{1,2,3};
std::queue<int> my_queue1(values);
std::queue<int> my_queue(my_queue1);
//或者使用
//std::queue<int> my_queue = my_queue1;

成员函数
empty()
如果 queue 中没有元素的话，返回 true。
size()
返回 queue 中元素的个数。
front()
返回 queue 中第一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
back()
返回 queue 中最后一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
push(const T& obj)
在 queue 的尾部添加一个元素的副本。这是通过调用底层容器的成员函数 push_back() 来完成的。
emplace()
在 queue 的尾部直接添加一个元素。
push(T&& obj)
以移动的方式在 queue 的尾部添加元素。这是通过调用底层容器的具有右值引用参数的成员函数 push_back() 来完成的。
pop()
删除 queue 中的第一个元素。
swap(queue &other_queue)
将两个 queue 容器适配器中的元素进行互换，需要注意的是，进行互换的 2 个 queue 容器适配器中存储的元素类型以及底层采用的基础容器类型，都必须相同。

三、priority_queue

priority_queue 容器适配器模拟的也是队列这种存储结构，即使用此容器适配器存储元素只能“从一端进（称为队尾），从另一端出（称为队头）”，且每次只能访问 priority_queue 中位于队头的元素。

但是，priority_queue 容器适配器中元素的存和取，遵循的并不是 “First in,First out”（先入先出）原则，而是“First in，Largest out”原则。直白的翻译，指的就是先进队列的元素并不一定先出队列，而是优先级最大的元素最先出队列。

STL 中，priority_queue 容器适配器的定义如下：

template <typename T,
        typename Container=std::vector<T>,
        typename Compare=std::less<T> >
class priority_queue{
    //......
}

可以看到，priority_queue 容器适配器模板类最多可以传入 3 个参数，它们各自的含义如下：
typename T：指定存储元素的具体类型；
typename Container：指定 priority_queue 底层使用的基础容器，默认使用 vector 容器。

作为 priority_queue 容器适配器的底层容器，其必须包含 empty()、size()、front()、push_back()、pop_back() 这几个成员函数，STL 序列式容器中只有 vector 和 deque 容器符合条件。

typename Compare：指定容器中评定元素优先级所遵循的排序规则，默认使用std::less按照元素值从大到小进行排序，还可以使用std::greater按照元素值从小到大排序，但更多情况下是使用自定义的排序规则。

其中，std::less 和 std::greater 都是以函数对象的方式定义在 头文件中。

priority_queue 容器适配器模板位于头文件中，并定义在 std 命名空间里

#include <queue>
using namespace std;

1. 创建一个空的 priority_queue 容器适配器，第底层采用默认的 vector 容器，排序方式也采用默认的 std::less 方法：

std::priority_queue<int> values;

2. 可以使用普通数组或其它容器中指定范围内的数据，对 priority_queue 容器适配器进行初始化：

//使用普通数组
int values[]{4,1,3,2};
std::priority_queue<int>copy_values(values,values+4);//{4,2,3,1}

//使用序列式容器
std::array<int,4>values{ 4,1,3,2 };
std::priority_queue<int>copy_values(values.begin(),values.end());//{4,2,3,1}

成员函数
empty()
如果 priority_queue 为空的话，返回 true；反之，返回 false。
size()
返回 priority_queue 中存储元素的个数。
top()
返回 priority_queue 中第一个元素的引用形式。
push(const T& obj)
根据既定的排序规则，将元素 obj 的副本存储到 priority_queue 中适当的位置。
push(T&& obj)
根据既定的排序规则，将元素 obj 移动存储到 priority_queue 中适当的位置。
emplace(Args&&… args)
Args&&… args 表示构造一个存储类型的元素所需要的数据（对于类对象来说，可能需要多个数据构造出一个对象）。此函数的功能是根据既定的排序规则，在容器适配器适当的位置直接生成该新元素。
pop()
移除 priority_queue 容器适配器中第一个元素。
swap(priority_queue& other)
将两个 priority_queue 容器适配器中的元素进行互换，需要注意的是，进行互换的 2 个 priority_queue 容器适配器中存储的元素类型以及底层采用的基础容器类型，都必须相同。

和 queue 一样，priority_queue 也没有迭代器，因此访问元素的唯一方式是遍历容器，通过不断移除访问过的元素，去访问下一个元素。