c++11 标准模板(STL)(std::queue)(五)

这篇具有很好参考价值的文章主要介绍了c++11 标准模板(STL)(std::queue)(五)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

定义于头文件 <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 算法。交换 lhsrhs 的内容。调用 lhs.swap(rhs) 。

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

(C++17 起)

参数

lhs, rhs - 要交换内容的容器

返回值

(无)

复杂度

与交换底层容器相同。

异常

noexcept 规定:  

noexcept(noexcept(lhs.swap(rhs)))

(C++17 起)

 文章来源地址https://www.toymoban.com/news/detail-420234.html

辅助类

特化 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);
}

输出

c++11 标准模板(STL)(std::queue)(五)

 

到了这里,关于c++11 标准模板(STL)(std::queue)(五)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • c++11 标准模板(STL)(std::unordered_multimap)(九)

    template     class Key,     class T,     class Hash = std::hashKey,     class KeyEqual = std::equal_toKey,     class Allocator = std::allocator std::pairconst Key, T class unordered_multimap; (1) (C++11 起) namespace pmr {     template class Key, class T,               class Hash = std::hashKey,               class Pred = std::equa

    2023年04月09日
    浏览(38)
  • c++11 标准模板(STL)(std::basic_ostream)(八)

    template     class CharT,     class Traits = std::char_traitsCharT class basic_ostream : virtual public std::basic_iosCharT, Traits 类模板 basic_ostream 提供字符流上的高层输出操作。受支持操作包含有格式输出(例如整数值)和无格式输出(例如生字符和字符数组)。此功能以 basic_streambuf 类所提供的接

    2024年02月12日
    浏览(39)
  • c++11 标准模板(STL)(std::basic_ifstream)(一)

    定义于头文件  fstream template     class CharT,     class Traits = std::char_traitsCharT class basic_ifstream : public std::basic_istreamCharT, Traits 类模板 basic_ifstream 实现文件流上的高层输入操作。它将 std::basic_istream 的高层接口赋予基于文件的流缓冲( std::basic_filebuf )。 std::basic_ifstream 的典型实

    2024年02月14日
    浏览(34)
  • c++11 标准模板(STL)(std::basic_stringstream)(四)

    template     class CharT,     class Traits = std::char_traitsCharT class basic_stringstream; (C++11 前) template     class CharT,     class Traits = std::char_traitsCharT,     class Allocator = std::allocatorCharT class basic_stringstream; (C++11 起) 类模板 std::basic_stringstream 实现基于字符串的流上的输入与输出操作。它等效

    2024年02月10日
    浏览(36)
  • c++11 标准模板(STL)(std::basic_istream)(三)

    template     class CharT,     class Traits = std::char_traitsCharT class basic_istream : virtual public std::basic_iosCharT, Traits  类模板 basic_istream 提供字符流上的高层输入支持。受支持操作包含带格式的输入(例如整数值或空白符分隔的字符与字符串)和无格式输入(例如未处理字符和字符数组)

    2024年02月13日
    浏览(39)
  • c++11 标准模板(STL)(std::basic_stringstream)(一)

    template     class CharT,     class Traits = std::char_traitsCharT class basic_stringstream; (C++11 前) template     class CharT,     class Traits = std::char_traitsCharT,     class Allocator = std::allocatorCharT class basic_stringstream; (C++11 起) 类模板 std::basic_stringstream 实现基于字符串的流上的输入与输出操作。它等效

    2024年02月10日
    浏览(39)
  • c++11 标准模板(STL)(std::basic_istream)(一)

    template     class CharT,     class Traits = std::char_traitsCharT class basic_istream : virtual public std::basic_iosCharT, Traits 类模板 basic_istream 提供字符流上的高层输入支持。受支持操作包含带格式的输入(例如整数值或空白符分隔的字符与字符串)和无格式输入(例如未处理字符和字符数组)。

    2024年02月13日
    浏览(31)
  • c++标准模板(STL)(std::array)(三)

    template     class T,     std::size_t N struct array; (C++11 起   std::array 是封装固定大小数组的容器。 此容器是一个聚合类型,其语义等同于保有一个 C 风格数组 T[N] 作为其唯一非静态数据成员的结构体。不同于 C 风格数组,它不会自动退化成 T* 。它能作为聚合类型聚合初始化,只要

    2024年02月02日
    浏览(48)
  • 0829|C++day7 auto、lambda、C++数据类型转换、C++标准模板库(STL)、list、文件操作

        封装一个学生的类,定义一个学生这样类的vector容器, 里面存放学生对象(至少3个) 再把该容器中的对象,保存到文件中。 再把这些学生从文件中读取出来,放入另一个容器中并且遍历输出该容器里的学生。

    2024年02月10日
    浏览(46)
  • 标准模板库STL——迭代器

    目录 四类迭代器概述 代码段 普通正向迭代器 普通反向迭代器 常量正向迭代器 常量反向迭代器 四类迭代器 普通正向迭代器 iterator 常量正向迭代器 const_iterator 普通反向迭代器 reverse_iterator 常量反向迭代器 const_reverse_iterator 解释说明 普通表示可以读元素,也可以写元素; 常量

    2024年02月12日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包