定义于头文件 <queue>

template<     class T,     class Container = std::deque<T> > class queue;

std::queue 类是容器适配器，它给予程序员队列的功能——尤其是 FIFO （先进先出）数据结构。

类模板表现为底层容器的包装器——只提供特定的函数集合。 queue 在底层容器尾端推入元素，从首端弹出元素。

成员对象

底层容器

Container c

非成员函数

按照字典顺序比较 queue 中的值

operator==,!=,<,<=,>,>=(std::queue)

template< class T, class Container > bool operator==( const queue<T,Container>& lhs,                  const queue<T,Container>& rhs );	(1)
template< class T, class Container > bool operator!=( const queue<T,Container>& lhs,                  const queue<T,Container>& rhs );	(2)
template< class T, class Container > bool operator<( const queue<T,Container>& lhs,                 const queue<T,Container>& rhs );	(3)
template< class T, class Container > bool operator<=( const queue<T,Container>& lhs,                  const queue<T,Container>& rhs );	(4)
template< class T, class Container > bool operator>( const queue<T,Container>& lhs,                 const queue<T,Container>& rhs );	(5)
template< class T, class Container > bool operator>=( const queue<T,Container>& lhs,                  const queue<T,Container>& rhs );	(6)

 比较二个容器适配器的底层容器。通过应用对应的运算符到底层容器进行比较。

参数

lhs, rhs	-	要比较内容的迭代器适配器
- T 必须满足可相等比较 (EqualityComparable) 的要求。

返回值

若对应比较产出 true 则为 true ，否则为 false 。

复杂度

与容器大小成线性

特化 std::swap 算法

std::swap(std::queue)

template< class T, class Container > void swap( queue<T,Container>& lhs,            queue<T,Container>& rhs );		(C++17 前)
template< class T, class Container > void swap( queue<T,Container>& lhs,            queue<T,Container>& rhs ) noexcept(/* see below */);		(C++17 起)

 为 std::queue 特化 std::swap 算法。交换 lhs 与 rhs 的内容。调用 lhs.swap(rhs) 。

此重载仅若 std::is_swappable<Container>::value 为 true 才参与重载决议。

(C++17 起)

参数

lhs, rhs

-

要交换内容的容器

返回值

（无）

复杂度

与交换底层容器相同。

异常

noexcept 规定：   noexcept(noexcept(lhs.swap(rhs)))

(C++17 起)

 

辅助类

特化 std::uses_allocator 类型特性

std::uses_allocator<std::queue>

template< class T, class Container, class Alloc > struct uses_allocator<queue<T,Container>,Alloc> :     std::uses_allocator<Container, Alloc>::type { };

(C++11 起)

为 std::queue 提供 std::uses_allocator 类型特性的通透特化：容器适配器使用分配器，若且唯若底层容器使用。

继承自 std::integral_constant

成员常量

value [静态]

true (公开静态成员常量)

成员函数

operator bool	转换对象为 bool ，返回 value (公开成员函数)
operator() (C++14)	返回 value (公开成员函数)

成员类型

类型	定义
value_type	bool
type	std::integral_constant<bool, value>

 

调用示例

#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;
    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;

    //2) 以 cont 的内容复制构造底层容器 c 。
    std::queue<Cell> queue1(deque1);
    std::queue<Cell> queue2(deque1);
    queuePrint("queue1:   ", queue1);
    queuePrint("queue2:   ", queue2);

    std::queue<Cell> queue3(deque2);
    queuePrint("queue3:   ", queue3);
    std::cout << std::endl;

    //比较二个容器适配器的底层容器。通过应用对应的运算符到底层容器进行比较。
    std::cout << "queue1 == queue2: " << (queue1 == queue2) << std::endl;
    std::cout << "queue1 == queue3: " << (queue1 == queue3) << std::endl;
    std::cout << "queue1 != queue2: " << (queue1 != queue2) << std::endl;
    std::cout << "queue1 != queue3: " << (queue1 != queue3) << std::endl;
    std::cout << "queue1 <  queue2: " << (queue1 <  queue2) << std::endl;
    std::cout << "queue1 <  queue3: " << (queue1 <  queue3) << std::endl;
    std::cout << "queue1 <= queue2: " << (queue1 <= queue2) << std::endl;
    std::cout << "queue1 <= queue3: " << (queue1 <= queue3) << std::endl;
    std::cout << "queue1 >  queue2: " << (queue1 >  queue2) << std::endl;
    std::cout << "queue1 >  queue3: " << (queue1 >  queue3) << std::endl;
    std::cout << "queue1 >= queue2: " << (queue1 >= queue2) << std::endl;
    std::cout << "queue1 >= queue3: " << (queue1 >= queue3) << std::endl;
    std::cout << std::endl;

    //为 std::queue 特化 std::swap 算法。交换 lhs 与 rhs 的内容。
    std::cout << "swap before:  " << std::endl;
    queuePrint("queue1:   ", queue1);
    queuePrint("queue3:   ", queue3);
    std::swap(queue1, queue3);
    std::cout << "swap after:  " << std::endl;
    queuePrint("queue1:   ", queue1);
    queuePrint("queue3:   ", queue3);
}

输出