c++11 标准模板（STL）（std::deque）（十）

于 2023-01-07 08:30:00 发布
阅读量901 收藏 5
点赞数 7
分类专栏： # std::deque 文章标签： c++ 容器 deque 双端队列 修改器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/128512372
版权

定义于头文件 <deque>

std::deque

修改器

移除首元素

std::deque<T,Allocator>::pop_front

void pop_front();

移除容器首元素。若容器中无元素，则行为未定义。

指向被擦除元素的迭代器和引用被非法化。若元素是容器中的最后元素，则尾后迭代器是否被非法化是未指定的。其他迭代器和引用不受影响。

(C++11 前)

指向被擦除元素的迭代器和引用被非法化。若元素是容器的最后元素，则尾后迭代器亦被非法化。其他迭代器和引用不受影响。

(C++11 起)

参数

（无）

返回值

（无）

复杂度

常数。

异常

不抛出。

 调用示例

        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;

        for (size_t index = 0; index < 3; index++)
        {
            //移除容器首元素。若容器中无元素，则行为未定义。
            deque1.pop_front();
            std::cout << "deque1 :  ";
            std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
            std::cout << std::endl;
        }
        std::cout << std::endl;

改变容器中可存储元素的个数

std::deque<T,Allocator>::resize

void resize( size_type count, T value = T() );

(C++11 前)

void resize( size_type count );

(1)(C++11 起)

void resize( size_type count, const value_type& value );

(2)(C++11 起)

重设容器大小以容纳 count 个元素。

若当前大小大于 count ，则减小容器为其首 count 个元素。

若当前大小小于 count ，则后附额外元素，并以 value 的副本初始化。

(C++11 前)

若当前大小小于 count ，

1) 则后附额外的默认插入的元素

2) 则后附额外的 value 的副本

(C++11 起)

参数

count-容器的大小
value-用以初始化新元素的值
类型要求
- 为使用重载 (1) ， T 必须满足可移动插入 (MoveInsertable) 和 可默认插入 (DefaultInsertable) 的要求。
- 为使用重载 (2) ， T 必须满足可复制插入 (CopyInsertable) 的要求。

返回值

（无）

复杂度

与当前大小和 count 间的差成线性。

 调用示例

        std::deque<Cell> deque1;
        //重设容器大小以容纳 count 个元素。
        deque1.resize(6);
        std::cout << "deque1 :  ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

        std::deque<Cell> deque2;
        //重设容器大小以容纳 count 个元素。
        deque2.resize(6, Cell{303, 303});
        std::cout << "deque2 :  ";
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

交换内容

std::deque<T,Allocator>::swap

void swap( deque& other );

(C++17 前)

void swap( deque& other ) noexcept(/* see below */);

(C++17 起)

将内容与 other 的交换。不在单个元素上调用任何移动、复制或交换操作。

所有迭代器和引用保持合法。尾后迭代器被非法化。

若 std::allocator_traits<allocator_type>::propagate_on_container_swap::value 为 true ，则用非成员 swap 的非限定调用交换分配器。否则，不交换它们（且若 get_allocator() != other.get_allocator() ，则行为未定义）。

(C++11 起)

参数

other-要与之交换内容的容器

返回值

（无）

异常

（无）

(C++17 前)
noexcept 规定：  

noexcept(std::allocator_traits<Allocator>::is_always_equal::value)

(C++17 起)

复杂度

常数。

 调用示例

        std::cout << "swap before:" << std::endl;
        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;

        //将内容与 other 的交换。不在单个元素上调用任何移动、复制或交换操作。
        deque1.swap(deque2);

        std::cout << "swap after:" << std::endl;

        std::cout << "deque1 :  ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

        std::cout << "deque2 :  ";
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

调用示例

#include <iostream>
#include <deque>
#include <string>
#include <algorithm>
#include <iterator>
#include <vector>
#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
    {
        return x == cell.x && y == cell.y;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

int main()
{
    std::mt19937 g{std::random_device{}()};

    srand((unsigned)time(NULL));;

    std::cout << std::boolalpha;

    auto generate = []()
    {
        int n = std::rand() % 10 + 100;
        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;

        for (size_t index = 0; index < 3; index++)
        {
            //移除容器首元素。若容器中无元素，则行为未定义。
            deque1.pop_front();
            std::cout << "deque1 :  ";
            std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }

    {
        std::deque<Cell> deque1;
        //重设容器大小以容纳 count 个元素。
        deque1.resize(6);
        std::cout << "deque1 :  ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

        std::deque<Cell> deque2;
        //重设容器大小以容纳 count 个元素。
        deque2.resize(6, Cell{303, 303});
        std::cout << "deque2 :  ";
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;
        std::cout << std::endl;
    }

    {
        std::cout << "swap before:" << std::endl;
        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;

        //将内容与 other 的交换。不在单个元素上调用任何移动、复制或交换操作。
        deque1.swap(deque2);

        std::cout << "swap after:" << std::endl;

        std::cout << "deque1 :  ";
        std::copy(deque1.begin(), deque1.end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;

        std::cout << "deque2 :  ";
        std::copy(deque2.begin(), deque2.end(), std::ostream_iterator<Cell>(std::cout, " "));
        std::cout << std::endl;
    }

    return 0;
}

输出

 

繁星璀璨G
关注
专栏目录
C++ 11 单例模板及使用方式
casic207的博客
10-09 171
#include <iostream> #include <string> #include <memory> template <typename T> class Singleton { public: template <typename... Args> static void createInstance(Args&&... args) { if (!m_sptrInstance) { m_spt.
C++11单例模板完全解决方案
笔记本专栏
06-25 561
class SingletonClass { private: SingletonClass() = default; ~SingletonClass() = default; SingletonClass(const SingletonClass& singletonClass) = delete; SingletonClass&operator...
C++设计模式——一个基于C++11的万用单例模板类
weixin_34199405的博客
11-06 480
2019独角兽企业重金招聘Python工程师标准>>> ...
基于C++11的单例模板的实现
weixin_54354418的博客
01-07 326
单例模板的实现单例模式代码实现使用问题及缺陷 单例模式 使用单例模式的目的是使得类在系统中的仅有一个实例 代码实现 #include <mutex> template<typename T> class Sington { protected: Sington() {} virtual ~Sington() {} public: template<typename... Args> static T* Instance(Args... args) {
C++11 单例模式
OneBaBa的专栏
07-29 454
单例模式
STL中的deque及源码实现 std::deque
我的大学
09-26 7478
本博客中涉及到的所有代码均在我的github上存放，地址：mySTL如果有兴趣的话可以去下载查看，注释比较详尽。说点什么相信大家如果对C++有一定的了解的话，都会知道C++中有STL这个超大的模版库，这个模版库提供了非常多的模版容器和模版算法，如常用的vector、list、stack、queue、map、set等等容器，sort、find_if、find、swap等模版函数 这个库由于创建时间过
std::Deque使用总结
大山喵写博客的地方
10-12 1万+
Deque
C++ STL 标准库 std::stack 总结
lih627
06-17 584
STL 标准库 stack 总结简介Constructor常用的成员函数 简介 Stack 是一种容器适配器/配接器(container adaptor), 被设计用来支持 LIFO 的数据结构. deque 是双向开口的数据结构, 因此以 deque 为底部结构封闭其头部开口, 就可以形成 Stack. adaptor 指的是通过修改某种容器的接口, 形成另一种数据结构, 因此他不被归类为容器. 他被定义在<stack> 头文件中, 如果使用必须引入改头文件, 定义方式为 template&
【C++】STL中deque底层剖析
xiaoxiaoguailou的博客
03-17 1043
文章目录一、关于deque二、底层结构（1）deque迭代器（2）deque结构（3）内存结构图 一、关于deque std::deque （ double-ended queue ，双端队列）是有下标顺序容器，它允许在其首尾两端快速插入及删除。另外，在 deque 任一端插入或删除不会非法化指向其余元素的指针或引用。 与 std::vector 相反， deque 的元素不是相接存储的：典型实现用单独分配的固定大小数组的序列，外加额外的登记，这表示下标访问必须进行二次指针解引用，与之相比 vector 的
《C++语言 - 标准模板库STL》_标准模板库_C++_C++STL_
09-29
学习C++STL，你需要理解如何创建和使用这些组件。对于容器，你需要知道何时选择哪种容器最适合你的需求，以及如何通过迭代器遍历和操作容器内的元素。同时，掌握常见算法的用法和性能特点也是必要的，这可以帮助你写...
C++面试 设计模式之单例模式（C++11）
fruit的博客
03-31 5250
单例模式 确保一个类只有一个实例，并提供了一个全局访问点。 单例模式，可以说设计模式中最常应用的一种模式了，据说也是面试官最喜欢的题目。但是如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况，可能会优先考虑使用全局或者静态变量的方式，这样比较简单，也是没学过设计模式的人所能想到的最简单的方式了。 一般情况下，我们建立的一些类是属于工具性质的，基本不用存储太多的跟自...
设计模式——单例模式（C++11实现）
Skynet的博客
02-18 787
C++11实现泛型单例模式，支持任意参数类的对象创建。采用了C++11的可变参数模板和完美转发技术 #include <iostream> #include <string> #include <stdexcept> using namespace std; //单例类，包含任意参数的类实例。 template <typename T> class Singleton { public: template <typename... Arg
c++11 标准模板（STL）（std::deque）（二）
qq_40788199的博客
12-30 762
从各种数据源构造新容器，可选地使用用户提供的分配器 alloc 。 1) 默认构造函数。构造拥有默认构造的分配器的空容器。 3) 构造拥有 count 个有值 value 的元素的容器。 4) 构造拥有个 count 默认插入的 T 实例的容器。不进行复制。 5) 构造拥有范围 [first, last) 内容的容器。 6) 复制构造函数。构造拥有 other 内容的容器。 7) 移动构造函数。用移动语义构造拥有 other 内容的容器。 9) 构造拥有 initializer_list init 内容的
c++11 标准模板（STL）（std::deque）（三）
最新发布
qq_40788199的博客
12-31 944
1) 复制赋值运算符。以 other 的副本替换内容。 2) 移动赋值运算符。用移动语义以 other 的内容替换内容。 3) 以 initializer_list ilist 所标识者替换内容。 1) 以 count 份 value 的副本替换内容。 2) 以范围 [first, last) 中元素的副本替换内容。 3) 以来自 initializer_list ilist 的元素替换内容。
C++/C++11中std::deque的使用
热门推荐
网络资源是无限的
05-25 4万+
C++/C++11中std::deque的使用
std::copy用法
weixin_43829023的博客
11-16 1万+
std::copy的用法 std::copy是C++标准库中的算法接口，主要用于两个容器间的复制，据说其效率要优于自己用for循环逐个复制。
c++11实现线程安全的单例模式
风起时~微凉的博客
03-31 456
c++11实现单例 线程安全的单例 实现单例模板
C++11 使用智能指针改进单例模式
HelloKandy's Blog
01-14 6029
本文主要关于如何使用C++11的智能指针改进单例模式。智能指针在C++11版本之后提供，包含在头文件中，shared_ptr、unique_ptr、weak_ptr。设计初衷：线程安全、垃圾回收、单例对象可接受多个参数。 1、使用shared_ptr 相对于一般的单例实现而言，使用了可变参数模板使得单例对象可接受多个参数： #pragma once #include <mutex> #include <memory> template<typename T> class
C++ STL标准模板库详解：从顺序容器到关联容器
"STL标准模板库笔记涵盖了C++中的主要容器、适配器和算法，为程序员提供了高效的数据结构实现。" STL（Standard Template Library，标准模板库）是C++编程语言的一个重要组成部分，它包含了一系列的类模板和算法，...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值