c++11 标准模板（STL）（std::queue）（三）

定义于头文件 <queue>

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

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

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

成员函数

赋值给容器适配器

std::queue<T,Container>::operator=

queue& operator=( const queue& other );	(1)
queue& operator=( queue&& other );	(2)	(C++11 起)

 以 other 的内容替换容器适配器的内容。

1) 复制赋值运算符。以 other 的内容副本替换内容。等效地调用 c = other.c; 。(隐式声明)

2) 移动赋值运算符。用移动语义以 other 的内容替换内容。等效地调用 c = std::move(other.c); 。(隐式声明)

参数

other

-

用作源的另一容器适配器

返回值

*this

复杂度

等价于底层容器 operator= 的复杂度。

容量

检查底层的容器是否为空

std::queue<T,Container>::empty

bool empty() const;		(C++20 前)
[[nodiscard]] bool empty() const;		(C++20 起)

检查底层容器是否为空，即是否 c.empty() 。

参数

（无）

返回值

若底层容器为空则为 true ，否则为 false 。

复杂度

常数

返回容纳的元素数

std::queue<T,Container>::size

size_type size() const;

返回底层容器中的元素数，即 c.size() 。

参数

（无）

返回值

容器中的元素数。

复杂度

常数。

调用示例

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

    //1) 复制赋值运算符。以 other 的内容副本替换内容。
    std::queue<Cell> queue2 = queue1;
    queuePrint("queue2:   ", queue2);
    //检查底层容器是否为空，即是否 c.empty() 。
    std::cout << "queue1 empty: " << queue1.empty() << std::endl;
    std::cout << std::endl;

    //2) 以 cont 的内容复制构造底层容器 c 。
    std::queue<Cell> queue3(deque1);
    std::queue<Cell> queue4 = std::move(queue3);
    queuePrint("queue4:   ", queue4);
    //检查底层容器是否为空，即是否 c.empty() 。
    std::cout << "queue3 empty: " << queue3.empty() << std::endl;
    std::cout << std::endl;

    std::queue<Cell> queue5;
    size_t index = 0;
    while (index < 5)
    {
        Cell cell = generate();
        queue5.push(cell);
        //返回底层容器中的元素数，即 c.size() 。
        std::cout << "queue5.push(" << cell << ")---size: " << queue5.size() << std::endl;
        index++;
    }
    std::cout << std::endl;

    while (index != 0)
    {
        Cell cell = queue5.front();
        queue5.pop();
        //返回底层容器中的元素数，即 c.size() 。
        std::cout << "queue5.pop()---" << cell << "size: " << queue5.size() << std::endl;
        index--;
    }
}

输出