本文声明：本文转载了多篇博客，每一篇博客的链接从上往下排序

转载地址 https://www.cnblogs.com/scandy-yuan/archive/2013/01/09/2853603.html

转载地址 https://blog.csdn.net/mangobar/article/details/81115449

转载地址 https://www.cnblogs.com/leaves1024/p/10245688.html

STL之deque容器详解

deque容器是C++标准模版库(STL,Standard Template Library)中的部分内容。deque容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：push_front()。

使用deque容器之前必须加上<deque>头文件：#include<deuqe>;

deque属于std命名域的内容，因此需要通过命名限定：using std::deque;也可以直接使用全局的命名空间方式：using namespace std;

构造函数

　　deque<Elem> c 创建一个空的deque

　　deque<Elem> c1(c2) 复制一个deque。

　　deque<Elem> c(n) 创建一个deque，含有n个数据，数据均已缺省构造产生。

　　deque<Elem> c(n, elem) 创建一个含有n个elem拷贝的deque。

　　deque<Elem> c(beg,end) 创建一个以[beg;end)区间的deque。

　　~deque<Elem>() 销毁所有数据，释放内存。

成员函数

c.begin()返回指向第一个元素的迭代器

c.end()返回指向最后一个元素下一个位置的迭代器

1     deque<int> d {1,2,3,4,5};
2     deque<int>::iterator it;
3     for(it=d.begin();it!=d.end();it++){
4         cout << *it << " ";
5     }
6     cout << endl;

c.rbegin()返回指向反向队列的第一个元素的迭代器(即原队列的最后一个元素)

c.rend()返回指向反向队列的最后一个元素的下一个位置(即原队列的第一个元素的前一个位置)

1     deque<int> d {1,2,3,4,5};
2     deque<int>::reverse_iterator it;
3     for(it=d.rbegin();it!=d.rend();it++){
4         cout << *it << " ";
5     }
6     cout << endl;

operator=赋值运算符重载

1     deque<int> d1 {1,2,3,4,5},d2;
2     d2 = d1;
3     deque<int>::iterator it;
4     for(it=d2.begin();it!=d2.end();it++){
5         cout << *it << " ";
6     }
7     cout << endl;

c.assign(n,num)将n个num拷贝复制到容器c

c.assign(beg,end)将[beg,end)区间的数据拷贝复制到容器c

 1     deque<int> d1 {1,2,3,4,5},d2;2     d2.assign(2, 8);3     deque<int>::iterator it;4     cout << "d2.assign(n,num):";5     for(it=d2.begin();it!=d2.end();it++){6         cout << *it << " ";7     }8     d2.assign(d1.begin(), d1.begin()+3);9     cout << "d2.assign(beg,end):";
10     for(it=d2.begin();it!=d2.end();it++){
11         cout << *it << " ";
12     }
13     cout << endl;

c.at(pos)返回索引为pos的位置的元素,会执行边界检查,如果越界抛出out_of_range异常

1     deque<int> d {1,2,3,4,5};
2     cout << "d.at(pos):" << d.at(2);
3     return 0;

c.operator[]下标运算符重载

1     deque<int> d {1,2,3,4,5};
2     cout << "d[2]:" << d[2];
3     return 0;

c.empty()判断c容器是否为空

1     deque<int> d {1,2,3,4,5};
2     if(!d.empty()){
3         cout << "d is not empty!" << endl;
4     }else{
5         cout << "d is empty!" << endl;
6     }
7     return 0;

c.front()返回c容器的第一个元素

c.back()返回c容器的最后一个元素

1     deque<int> d {1,2,3,4,5};
2     if(!d.empty()){
3         cout << "d.front():" << d.front() << endl;
4         cout << "d.back(): " << d.back() << endl;
5     }

c.size()返回c容器中实际拥有的元素个数

1     deque<int> d {1,2,3,4,5};
2     cout << "d.size():" << d.size() << endl;
3     return 0;

c.max_size()返回c容器可能存放元素的最大数量

1     deque<int> d {1,2,3,4,5};
2     cout << "d.max_size():" << d.max_size() << endl;
3     return 0;

c.clear()清除c容器中拥有的所有元素

 1     deque<int> d {1,2,3,4,5};2     deque<int>::iterator it;3     cout << "clear before:" ;4     for(it=d.begin();it!=d.end();it++){5         cout << *it << " ";6     }7     cout << endl;8     d.clear();9     cout << "clear after:" ;
10     for(it=d.begin();it!=d.end();it++){
11         cout << *it << " ";
12     }
13     cout << endl;

c.insert(pos,num)在pos位置插入元素num

c.insert(pos,n,num)在pos位置插入n个元素num

c.insert(pos,beg,end)在pos位置插入区间为[beg,end)的元素

 1     deque<int> d {1,2,3,4,5};2     deque<int>::iterator it;3     cout << "insert before:" ;4     for(it=d.begin();it!=d.end();it++){5         cout << *it << " ";6     }7     cout << endl;8     d.insert(d.end(),22);9     d.insert(d.end(), 3,88);
10     int a[5] = {1,2,3,4,5};
11     d.insert(d.begin(),a,a+3);
12     cout << "insert after:" ;
13     for(it=d.begin();it!=d.end();it++){
14         cout << *it << " ";
15     }
16     cout << endl;

c.erase(pos)删除pos位置的元素c.erase(beg,end)删除区间为[beg,end)的元素

c.erase(beg,end)删除区间为[beg,end)之间的元素

 1     deque<int> d {1,2,3,4,5};2     d.erase(d.begin());3     deque<int>::iterator it;4     cout << "erase(pos) after:" ;5     for(it=d.begin();it!=d.end();it++){6         cout << *it << " ";7     }8     cout << endl;9     d.erase(d.begin(), d.begin()+3);
10     cout << "erase(beg,end) after:" ;
11     for(it=d.begin();it!=d.end();it++){
12         cout << *it << " ";
13     }
14     cout << endl;

c.push_back(num)在末尾位置插入元素

c.pop_back()删除末尾位置的元素

c.push_front(num)在开头位置插入元素

c.pop_front()删除开头位置的元素

 1     deque<int> d {1,2,3,4,5};2     d.push_back(10);3     deque<int>::iterator it;4     cout << "push_back(num):" ;5     for(it=d.begin();it!=d.end();it++){6             cout << *it << " ";7     }8     cout << endl;9
10     d.pop_back();
11     cout << "pop_back(num):" ;
12     for(it=d.begin();it!=d.end();it++){
13         cout << *it << " ";
14     }
15     cout << endl;
16
17     d.push_front(10);
18     cout << "push_front(num):" ;
19     for(it=d.begin();it!=d.end();it++){
20         cout << *it << " ";
21     }
22     cout << endl;
23
24     d.pop_front();
25     cout << "pop_front(num):" ;
26     for(it=d.begin();it!=d.end();it++){
27         cout << *it << " ";
28     }
29     cout << endl;
30     return 0;

c.resize(num)从新定义容器的大小

 1     deque<int> d {1,2,3,4,5};2     cout << "d.size():" << d.size() << endl;3     d.resize(d.size()+5);4     cout << "d.resize() after:" << d.size() <<endl;5     deque<int>::iterator it;6     cout << "resize() after:" ;7     for(it=d.begin();it!=d.end();it++){8     cout << *it << " ";9     }
10     cout << endl;

c1.swap(c2)交换容器c1,c2;

swap(c1,c2)同上。

 1     deque<int> d1 {1,2,3,4,5},d2,d3;2     d1.swap(d2);3     deque<int>::iterator it;4     cout << "d1 swap after:" ;5     for(it=d1.begin();it!=d1.end();it++){6         cout << *it << " ";7     }8     cout << endl;9     cout << "d2 swap after:" ;
10     for(it=d2.begin();it!=d2.end();it++){
11         cout << *it << " ";
12     }
13     cout << endl;
14
15     swap(d3,d2);
16     cout << "d3 swap after:" ;
17     for(it=d3.begin();it!=d3.end();it++){
18         cout << *it << " ";
19     }
20     cout << endl;

重载运算符

operator==

operator!=

operator<

operator<=

operator>

operator>=

迭代器

string对象或vector对象可以通过下标访问每一个元素，迭代器也具有同样的效果。那又有什么不同呢？事实上并不是所有的容器到可以使用下标访问每一个元素，即在容器上迭代器更具普适性。string类支持迭代器，同vector一样。

std::atomic

　　std::atomic对int, char, bool等数据结构进行原子性封装，在多线程环境中，对std::atomic对象的访问不会造成竞争-冒险。利用std::atomic可实现数据结构的无锁设计。

C++11给我们带来的Atomic一系列原子操作类，它们提供的方法能保证具有原子性。这些方法是不可再分的，获取这些变量的值时，永远获得修改前的值或修改后的值，不会获得修改过程中的中间数值。

std::vector简介及其使用

本文中的vector指的是std::vector C++11标准。

Vector概述

template <class T，class Alloc = allocator <T> > class vector; //通用模板

　　vector是表示可以改变大小的数组的序列容器。

　　就像数组一样，vector使用连续存储空间存储元素，这意味着它们的元素也可以使用指向其元素的指针进行偏移来访问，并与数组一样高效。但与数组不同的是， vector的大小可以动态变化，并且是由容器自动处理的。

　　在内部实现上，vector使用动态分配的数组来存储它们的元素。在插入新元素时，vector的大小增大，可能需要重新分配数组，这意味着可能要分配新数组并将原有数组中所有元素移动到这个新数组中。重新分配数组的时间成本相对高昂，因此，vector不会在每次向容器添加元素时都重新分配数组。vector容器可能会分配一些额外的存储空间来适应可能的增长，因此容器的实际容量可能比其包含的元素个数要大。不同库可以实现不同的增长策略以在使用现有内存和 重新分配内容之间取得平衡，但无论如何，重新分配内存时的数组大小应以对数增长，这样在vector末端插入单个元素时就可以得到平摊的常数时间复杂度。

　　因此，与数组相比，vector消耗更多内存，以换取以更有效的方式管理存储空间。

　　与其他动态序列容器（deques，lists和forward_lists）相比，vector可以非常高效地访问其元素（就像数组一样）并且相对高效地从其末尾添加或删除元素。 对于涉及在末尾以外的位置插入或删除元素的操作，性能比其他序列容器要差，并且与lists和forward_lists相比具有更少的迭代器和引用一致性。

容器属性

• 顺序存储

　　序列容器中的元素按照严格的线性顺序存储。各个元素通过使用它们在这个序列中的位置（index）来访问。

• 动态数组

　　允许直接访问序列中的任何元素，支持指针运算，相对快速的添加/删除序列末尾的元素。

• 分配器

　　 容器使用allocator对象来动态处理其存储需求。

模板参数

• T

　　元素的类型。只有当 T 保证在移动操作时不会抛出异常，实现才会进行优化，即在重新分配数组时移动元素而不是复制它们。

　　别名为成员类型 vector :: value_type。

• Alloc

　　用于定义分配模型的分配器对象的类型。默认情况下，使用allocator类模板，该模板定义最简单的内存分配模型，并且与值无关。

　　别名为成员类型 vector :: allocator_type。

成员类型

成员函数

•  (constructor) 构造函数

explicit vector (const allocator_type& alloc = allocator_type());

explicit vector (size_type n);
vector (size_type n, const value_type& val,const allocator_type& alloc = allocator_type());

template <class InputIterator>
vector (InputIterator first, InputIterator last,const allocator_type& alloc = allocator_type());

vector (const vector& x);
vector (const vector& x, const allocator_type& alloc);

vector (vector&& x);
vector (vector&& x, const allocator_type& alloc);

vector (initializer_list<value_type> il,const allocator_type& alloc = allocator_type());

　　构造函数示例：

// constructing vectors
#include <iostream>
#include <vector>int main ()
{// constructors used in the same order as described above:std::vector<int> first;                                // empty vector of intsstd::vector<int> second (4,100);                       // four ints with value 100std::vector<int> third (second.begin(),second.end());  // iterating through secondstd::vector<int> fourth (third);                       // a copy of third// the iterator constructor can also be used to construct from arrays:int myints[] = {16,2,77,29};std::vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );std::cout << "The contents of fifth are:";for (std::vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)std::cout << ' ' << *it;std::cout << '\n';return 0;
}Output:
The contents of fifth are: 16 2 77 29 

• (destructor) 析构函数

~vector();

• operator= 赋值

vector& operator= (const vector& x);

vector& operator= (vector&& x);

vector& operator= (initializer_list<value_type> il);

•  迭代器相关

　　迭代器示例：

// vector::begin/end
#include <iostream>
#include <vector>int main ()
{std::vector<int> myvector;for (int i=1; i<=5; i++)myvector.push_back(i);std::cout << "myvector contains:";for (std::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it)std::cout << ' ' << *it;std::cout << '\n';return 0;
}Output:
myvector contains: 1 2 3 4 5

•  容器大小或容量相关

　　示例：

// comparing size, capacity and max_size
#include <iostream>
#include <vector>int main ()
{std::vector<int> myvector;// set some content in the vector:for (int i=0; i<100; i++)myvector.push_back(i);std::cout << "size: " << (int) myvector.size() << '\n';std::cout << "capacity: " << (int) myvector.capacity() << '\n';std::cout << "max_size: " << (int) myvector.max_size() << '\n';return 0;
}A possible output for this program could be:
size: 100
capacity: 128
max_size: 1073741823

• 成员访问相关

　　成员访问示例：

// vector::operator[]
#include <iostream>
#include <vector>int main ()
{std::vector<int> myvector (10);   // 10 zero-initialized elementsstd::vector<int>::size_type sz = myvector.size();// assign some values:for (unsigned i=0; i<sz; i++) myvector[i]=i;// reverse vector using operator[]:for (unsigned i=0; i<sz/2; i++){int temp;temp = myvector[sz-1-i];myvector[sz-1-i]=myvector[i];myvector[i]=temp;}std::cout << "myvector contains:";for (unsigned i=0; i<sz; i++)std::cout << ' ' << myvector[i];std::cout << '\n';return 0;
}Output:
myvector contains: 9 8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------
// vector::at
#include <iostream>
#include <vector>int main ()
{std::vector<int> myvector (10);   // 10 zero-initialized ints// assign some values:for (unsigned i=0; i<myvector.size(); i++)myvector.at(i)=i;std::cout << "myvector contains:";for (unsigned i=0; i<myvector.size(); i++)std::cout << ' ' << myvector.at(i);std::cout << '\n';return 0;
}Output:
myvector contains: 0 1 2 3 4 5 6 7 8 9
----------------------------------------------------------------------
// vector::front
#include <iostream>
#include <vector>int main ()
{std::vector<int> myvector;myvector.push_back(78);myvector.push_back(16);// now front equals 78, and back 16myvector.front() -= myvector.back();std::cout << "myvector.front() is now " << myvector.front() << '\n';return 0;
}Output:
myvector.front() is now 62
----------------------------------------------------------------------
// vector::back
#include <iostream>
#include <vector>int main ()
{std::vector<int> myvector;myvector.push_back(10);while (myvector.back() != 0){myvector.push_back ( myvector.back() -1 );}std::cout << "myvector contains:";for (unsigned i=0; i<myvector.size() ; i++)std::cout << ' ' << myvector[i];std::cout << '\n';return 0;
}Output:
myvector contains: 10 9 8 7 6 5 4 3 2 1 0
----------------------------------------------------------------------
// vector::data
#include <iostream>
#include <vector>int main ()
{std::vector<int> myvector (5);int* p = myvector.data();*p = 10;++p;*p = 20;p[2] = 100;std::cout << "myvector contains:";for (unsigned i=0; i<myvector.size(); ++i)std::cout << ' ' << myvector[i];std::cout << '\n';return 0;
}Output:
myvector contains: 10 20 0 100 0成员访问示例

• 添加、删除等修改相关操作

　　示例：

// vector assign
#include <iostream>
#include <vector>int main ()
{std::vector<int> first;std::vector<int> second;std::vector<int> third;first.assign (7,100);             // 7 ints with a value of 100std::vector<int>::iterator it;it=first.begin()+1;second.assign (it,first.end()-1); // the 5 central values of firstint myints[] = {1776,7,4};third.assign (myints,myints+3);   // assigning from array.std::cout << "Size of first: " << int (first.size()) << '\n';std::cout << "Size of second: " << int (second.size()) << '\n';std::cout << "Size of third: " << int (third.size()) << '\n';return 0;
}Output:
Size of first: 7
Size of second: 5
Size of third: 3
----------------------------------------------------------------------
// inserting into a vector
#include <iostream>
#include <vector>int main ()
{std::vector<int> myvector (3,100);std::vector<int>::iterator it;it = myvector.begin();it = myvector.insert ( it , 200 );myvector.insert (it,2,300);// "it" no longer valid, get a new one:it = myvector.begin();std::vector<int> anothervector (2,400);myvector.insert (it+2,anothervector.begin(),anothervector.end());int myarray [] = { 501,502,503 };myvector.insert (myvector.begin(), myarray, myarray+3);std::cout << "myvector contains:";for (it=myvector.begin(); it<myvector.end(); it++)std::cout << ' ' << *it;std::cout << '\n';return 0;
}Output:
myvector contains: 501 502 503 300 300 400 400 200 100 100 100

• Allocator相关

重载的非成员函数

特例

　　注：vector<bool>使用不慎可能会出问题，一般都建议不要使用。

C++ 知识补给（二）相关推荐

1. BMP格式知识之二:16位,24位,32位的BMP图片算法是如何运算的

   BMP格式知识之二:16位,24位,32位的BMP图片算法是如何运算的 原文:http://blog.csdn.net/qq445803843/article/details/46476433 这段代 ...

2. Python基础数据之列表知识（二）

   Python基础数据之列表知识(二) 一.列表的特点 二.列表的排序 三.列表的嵌套 1.嵌套的基本使用 2.嵌套的示例 四.列表的循环删除 五.列表相关知识链接 一.列表的特点 1.有序 2.独立 ...

3. linux知识（二）互斥量、信号量和生产者消费者模型

   linux知识(二)互斥量.信号量和生产者消费者模型 一.互斥量 产生原因 二.信号量 生产者消费者模型 一.互斥量 产生原因 使用多线程常常会碰到数据混乱的问题,那么使用互斥量,相当于"加 ...

4. JavaScript知识（二）

   JavaScript知识(二) 原文:JavaScript知识(二) 你要保守你心,胜过保守一切,因为一生的果效,是由心发出的.----O(∩_∩)O... ...O(∩_∩)O...老师因有事下午没 ...

5. Android基础知识（二十）：Notification、提醒式通知（横幅）踩坑与通知界面设置跳转

   Android基础知识(二十):Notification.提醒式通知(横幅)踩坑与通知界面设置跳转 一.Notification通知与基本用法 通知Notification是Android系统中比较有 ...

6. （硅谷课堂项目）Java开发笔记4：前端基础知识（二）

   文章目录 (硅谷课堂项目)Java开发笔记4:前端基础知识(二) 一.NPM 1.NPM简介 1.1.什么是NPM 1.2.NPM工具的安装位置 2.使用npm管理项目 2.1.创建文件夹npm 2. ...

7. 概率论基础知识（二） 随机变量及其分布

   概率论基础知识(二) 随机变量及其分布 1.随机变量 定义:设随机试验的样本空间为S={e}, X=X(e)是定义在样本空间S上的实值单值函数.称X=X(e)为随机变量. 这样一来,样本空间可以很好的 ...

8. web前端知识总结二（css（其他）+移动web网页开发）

   web前端知识总结二(css(其他)+移动web网页开发) 文章目录 web前端知识总结二(css(其他)+移动web网页开发) 字体图标 平面转换-位移 位移:绝对定位居中 开门效果 旋转 转换原点 ...

9. 计算广告基础知识（二）

   计算广告基础知识(二) 刘鹏老师<计算广告:互联网商业变现的市场与技术>读书笔记 计算广告基础知识二 重点名词 合约广告 受众定向 流量预测traffic forecasting 流量塑形 ...

10. 自知识蒸馏（知识蒸馏二）

    自知识蒸馏(知识蒸馏二) 自知识蒸馏(知识蒸馏二) Born-Again Neural Networks(ICML2018) 方法 为什么有效 实验结果 Training Deep Neural Ne ...

最新文章

1. SpringBoot 定时任务动态管理通用解决方案
2. 怎么优雅的处理Java异常？
3. adf4351_在ADF实体PK属性中使用MySQL自动增量PK列
4. 计算机二级vfp模拟考试题,计算机等级考试二级VFP模拟练习题[10]
5. RMAN SET NEWNAME
6. 18 安装zlib报错_scalapack win安装及mingw64环境配置
7. 用homebrew 升级安装python3.7 之后系统的python版本还是旧的怎么办
8. linux下expect环境安装以及简单脚本测试
9. 拓端tecdat|R语言泰坦尼克号随机森林模型案例数据分析
10. 游戏 编程 语言 服务端 客户端 就业
11. SE 2.4.0 patch机器码笔记
12. 2021-6-26 激光的工业应用
13. Flutter之导航栏骨架实现
14. 心灵鸡汤——人生哲理
15. uni-app ucharts无法显示
16. 高通平台安卓手机开机
17. RF：Robot命令行工具帮助文件中文译版（个人翻译）
18. Element table各种合并单元格
19. 浅谈Coreseek、Sphinx-for-chinaese、Sphinx+Scws的区别
20. Java基础 IP地址

热门文章

1. DataHub: 现代数据栈的元数据平台的Metadata Ingestion Architecture【元数据摄取架构】讲解
2. 目前有哪些高并发解决方案？
3. 【软件分析/静态程序分析学习笔记】3.数据流分析(Data Flow Analysis) (上)：可达性分析(Reaching Definitions)
4. strut-控制器ActionServlet类详解
5. 程序员应该学什么语言
6. 优化计算机组策略,7种优化技巧优化Windows 10系统 提高电脑性能
7. matlab画运动轨迹,Matlab画小球沿轨迹运动
8. C语言中文网 读后感
9. ONLYOFFICE权限开发之二
10. hdu 6357 Hills And Valleys——dp