定义于头文件 <queue>
| template< class T, |
std::queue 类是容器适配器，它给予程序员队列的功能——尤其是 FIFO （先进先出）数据结构。
类模板表现为底层容器的包装器——只提供特定的函数集合。 queue 在底层容器尾端推入元素，从首端弹出元素。
修改器
向队列尾部插入元素
std::queue<T,Container>::push| void push( const value_type& value ); |
||
| void push( value_type&& value ); |
(C++11 起) |
推给定的元素 value 到 queue 尾。
1) 等效地调用 c.push_back(value)
2) 等效地调用 c.push_back(std::move(value))
参数
| value | - | 要推入的元素值 |
返回值
（无）
复杂度
等于 Container::push_back 的复杂度。
于尾部原位构造元素
std::queue<T,Container>::emplace| template< class... Args > |
(C++11 起) (C++17 前) |
|
| template< class... Args > |
(C++17 起) |
推入新元素到 queue 结尾。原位构造元素，即不进行移动或复制操作。以与提供给函数者准确相同的参数调用元素的构造函数。
等效地调用 c.emplace_back(std::forward<Args>(args)...); 。
参数
| args | - | 转发给元素构造函数的参数 |
返回值
| （无） | (C++17 前) |
| 上述对 Container::emplace_back 的调用返回的值或引用，若它存在。 | (C++17 起) |
复杂度
等同于 Container::emplace_back 的复杂度。
删除栈顶元素
std::queue<T,Container>::pop| void pop(); |
从 queue 移除前端元素。等效地调用 c.pop_front() 。
参数
（无）
返回值
（无）
复杂度
等于 Container::pop_front 的复杂度。
交换内容
std::queue<T,Container>::swap| void swap( queue& other ) noexcept(/* see below */); |
(C++11 起) |
交换容器适配器与 other 的内容。等效地调用 using std::swap; swap(c, other.c); 。
参数
| other | - | 要交换内容的容器适配器 |
返回值
（无）
示例
| noexcept 规定： noexcept(noexcept(swap(c, other.c))) 上述表达式中，用与 C++17 std::is_nothrow_swappable 特性所用的相同方式查找标识符 |
(C++17 前) |
| noexcept 规定： noexcept(std::is_nothrow_swappable<Container>::value) |
(C++17 起) |
复杂度
与底层容器相同（典型地为常数）。
调用示例
#include <iostream>
#include <forward_list>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <queue>
#include <deque>
#include <time.h>
using namespace std;
struct Cell
{
int x;
int y;
Cell() = default;
Cell(int a, int b): x(a), y(b) {}
Cell &operator +=(const Cell &cell)
{
x += cell.x;
y += cell.y;
return *this;
}
Cell &operator +(const Cell &cell)
{
x += cell.x;
y += cell.y;
return *this;
}
Cell &operator *(const Cell &cell)
{
x *= cell.x;
y *= cell.y;
return *this;
}
Cell &operator ++()
{
x += 1;
y += 1;
return *this;
}
bool operator <(const Cell &cell) const
{
if (x == cell.x)
{
return y < cell.y;
}
else
{
return x < cell.x;
}
}
bool operator >(const Cell &cell) const
{
if (x == cell.x)
{
return y > cell.y;
}
else
{
return x > cell.x;
}
}
bool operator ==(const Cell &cell) const
{
return x == cell.x && y == cell.y;
}
};
std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
os << "{" << cell.x << "," << cell.y << "}";
return os;
}
void queuePrint(const std::string &name, const std::queue<Cell> &queue)
{
std::cout << name ;
std::queue<Cell> queuep = queue;
while (queuep.size() > 0)
{
std::cout << queuep.front() << " ";
queuep.pop();
}
std::cout << std::endl;
}
int main()
{
std::cout << std::boolalpha;
std::mt19937 g{std::random_device{}()};
srand((unsigned)time(NULL));
auto generate = []()
{
int n = std::rand() % 10 + 110;
Cell cell{n, n};
return cell;
};
std::deque<Cell> deque1(6);
std::generate(deque1.begin(), deque1.end(), generate);
std::cout << "deque1: ";
std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
std::cout << std::endl;
//2) 以 cont 的内容复制构造底层容器 c 。
std::queue<Cell> queue1(deque1);
while (!queue1.empty())
{
//返回到 queue 中首元素的引用。
//此元素将是调用 pop() 时第一个移除的元素。等效地调用 c.front() 。
//const_reference
std::cout << "queue1.front() before: " << queue1.front() << " ";
//reference
queue1.front() = generate();
std::cout << "after: " << queue1.front();
//从 queue 移除顶元素。等效地调用 c.pop_back()
queue1.pop();
std::cout << std::endl;
}
std::cout << std::endl;
std::queue<Cell> queue2;
int index = 0;
while (index < 6)
{
Cell cell = generate();
if (queue2.size() % 2 == 0)
{
//推给定的元素 value 到 queue 尾。
//1) 等效地调用 c.push_back(value)
queue2.push(cell);
}
else
{
//推给定的元素 value 到 queue 尾。
//2) 等效地调用 c.push_back(std::move(value)),移动语义
queue2.push(std::move(cell));
}
std::cout << "queue2.front() : " << queue2.front() ;
queue2.pop();
std::cout << std::endl;
index++;
}
std::cout << std::endl;
std::queue<Cell> queue3;
index = 0;
while (index < 6)
{
int n = std::rand() % 10 + 110;
//推入新元素到 queue 结尾。原位构造元素，即不进行移动或复制操作。
//以与提供给函数者准确相同的参数调用元素的构造函数。
//等效地调用 c.emplace_back(std::forward<Args>(args)...);
queue3.emplace(n, n);
std::cout << "queue3.front() : " << queue3.front() ;
std::cout << std::endl;
queue3.pop();
index++;
}
std::cout << std::endl;
std::deque<Cell> deque2(6);
std::generate(deque2.begin(), deque2.end(), generate);
std::cout << "deque2: ";
std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<Cell>(std::cout, " "));
std::cout << std::endl;
std::deque<Cell> deque3(6);
std::generate(deque3.begin(), deque3.end(), generate);
std::cout << "deque3: ";
std::copy(deque3.begin(), deque3.end(), std::ostream_iterator<Cell>(std::cout, " "));
std::cout << std::endl;
std::cout << std::endl;
std::queue<Cell> queue4(deque2);
std::queue<Cell> queue5(deque3);
std::cout << "swap before: " << std::endl;
queuePrint("queue4: ", queue4);
queuePrint("queue5: ", queue5);
//交换容器适配器与 other 的内容。
//等效地调用 using std::swap; swap(c, other.c);
queue4.swap(queue5);
std::cout << "swap after: " << std::endl;
queuePrint("queue4: ", queue4);
queuePrint("queue5: ", queue5);
}输出
