deque 是 double-ended deque 的縮寫。它是一種動態數組形式，可以向兩端發展，因此不論在尾部或頭部插入元素，都十分迅速。在中間部分插入元素則比較費時，因爲必須移動其他元素。這是一種隨機訪問的數據類型，提供了在序列兩端快速插入和刪除操作的功能，它可以在需要的時候修改其自身大小。也就是說這是一種雙端隊列容器，完成了標準的C++數據結構中隊列的所有功能。deque對象在序列的兩端放置元素和刪除元素是高效的，而 vector 容器只是在插入序列尾部時操作纔是高效的。
請看定義：
template<class T, class A = allocator<T> >
class deque
{
public:
//定義內存分配器類型 A 的別名
typedef A allocator_type;
//定義內存分配器 A 大小的別名, 可以代表容器的長度的類型, uint
typedef A::size_type size_type;
//代表兩個不同的元素之前地址差異的類型, int
typedef A::difference_type difference_type;
//T 的引用類型
typedef A::reference reference;
//T 的常量引用類型
typedef A::const_reference const_reference;
//對象類型T, 存儲在 deque 容器中
typedef A::value_type value_type;
//定義訪問 deque 的迭代器類型
typedef T0 iterator;
//定義訪問 deque 的常量迭代器類型
typedef T1 const_iterator;
//定義訪問 deque 的反向迭代器類型
typedef reverse_iterator<iterator, value_type, reference, A::pointer, difference_type> reverse_iterator;
//定義訪問 deque 的常量反向迭代器類型
typedef reverse_iterator<const_iterator, value_type, const_reference, A::const_pointer, difference_type> const_reverse_iterator;
//默認構造函數, A爲內存分配器
explicit deque(const A& al = A());
//構造函數, 構造 n 個值爲 v 的元素
explicit deque(size_type n, const T& v = T(), const A& al = A());
//拷貝構造函數
deque(const deque& x);
//構造函數, 範圍爲 [first, last)
deque(const_iterator first, const_iterator last, const A& al = A());
//返回 deque 的頭指針
iterator begin();
//返回 deque 的常量頭指針
const_iterator begin() const;
//返回 deque 的尾指針
iterator end();
//返回 deque 的尾指針
iterator end() const;
//返回反向迭代器引用, 它指向 deque 的尾部
reverse_iterator rbegin();
//返回反向迭代器常量引用, 它指向 deque 的尾部
const_reverse_iterator rbegin() const;
//返回反向迭代器引用, 它指向 deque 第一個元素
reverse_iterator rend();
//返回反向迭代器常量引用, 它指向 deque 第一個元素
const_reverse_iterator rend() const;
//重新設置元素個數爲 n, 確保 size() 返回值爲 n
void resize(size_type n, T x = T());
//返回 deque 元素數量
size_type size() const;
//返回最大可允許的 deque 元素數量值
size_type max_size() const;
//判斷 deque 是否爲空
bool empty() const;
//返回保護成員, 內存分配器
A get_allocator() const;
//返回位置在 pos 的元素的引用
reference at(size_type pos);
//返回位置在 pos 的元素的常量引用
const_reference at(size_type pos) const;
//重載 [], 返回位置在 pos 的元素的引用
reference operator[](size_type pos);
//重載 [], 返回位置在 pos 的元素的常量引用
const_reference operator[](size_type pos);
//返回第一個元素的引用
reference front();
//返回第一個元素的常量引用
const_reference front() const;
//返回最後一個元素的引用
reference back();
//返回最後一個元素的常量引用
const_reference back() const;
//在 deque 的頭部插入一個元素 x
void push_front(const T& x);
//刪除第一個元素
void pop_front();
//在 deque 的尾部插入一個元素 x
void push_back(const T& x);
//刪除最後一個元素
void pop_back();
//清空 deque 以前的內容, 並重新將範圍爲 [first, last) 的元素賦值給容器
void assign(const_iterator first, const_iterator last);
//清空 vector 以前的內容, 並重新將 n 個 x 賦值給 deque
void assign(size_type n, const T& x = T());
//在位置 it 前插入 x
iterator insert(iterator it, const T& x = T());
//在位置 it 前插入 n 個 x
void insert(iterator it, size_type n, const T& x);
//在位置 it 前插入範圍爲 [first, last) 的元素
void insert(iterator it, const_iterator first, const_iterator last);
//刪除位置在 it 的元素
iterator erase(iterator it);
//刪除在 [first, last) 範圍內的元素
iterator erase(iterator first, iterator last);
//刪除所有元素
void clear();
//交換兩個 vector 的元素
void swap(deque x);
protected:
//內存分配器, 允許你自定義一個內存分配器. 如果不自定義, 就用默認的
//對內存分配會有特別的要求, 這時候就要自定一個分配器
A allocator;
};(1) deque 容器的初始化與賦值
#include <iostream>
#include <deque>
#include <algorithm>
#include <string>
int main()
{
//構造函數, 開闢10個元素, 初值全部爲0
std::deque<int> deq(10, 0);
//首部插入兩個元素
deq.push_front(1);
deq.push_front(2);
//首部彈出一個元素
deq.pop_front();
//尾部插入兩個元素
deq.push_back(1);
deq.push_back(2);
//尾部彈出一個元素
deq.pop_back();
//遍歷元素
std::deque<int>::iterator iter;
for (iter = deq.begin(); iter != deq.end(); iter++)
{
std::cout << *iter << std::endl;
}
return 0;
}(2) deque容器size()、max_size()、capacity()方法的使用：
#include <iostream>
#include <deque>
#include <algorithm>
#include <string>
int main()
{
std::deque<std::string> deq;
//壓入一個元素
deq.push_back("Element 1");
//.size(): 當前元素的個數
std::cout << "size() = " << deq.size() << std::endl; //Output:1
//.max_size: 序列可控對象的個數, 允許開闢元素最大數量
std::cout << "max_size() = " << deq.max_size() << std::endl; //Output:134217727
//當前 deque 容器不支持使用 capacity() 計算容器的容量
//當前 deque 容器不支持使用 reserve() 預留空間
std::cout << "size() = " << deq.size() << std::endl; //Output:1
std::cout << "max_size() = " << deq.max_size() << std::endl; //Output:134217727
//重新調整元素數量; 它不僅開闢了內存, 而且放置了空的新元素
deq.resize(2000);
std::cout << "size() = " << deq.size() << std::endl; //Output:2000
std::cout << "max_size() = " << deq.max_size() << std::endl; //Output:134217727
return 0;
}(3) deque 容器是否爲空：
//判斷容器是否爲空
deq.empty();(4) deque 容器之元素訪問：
#include <iostream>
#include <deque>
#include <algorithm>
#include <string>
int main()
{
std::deque<std::string> deq;
//首部插入元素
deq.push_front("Element 1");
//尾部插入元素
deq.push_back("Element 2");
//使用 for 循環訪問
for (size_t index = 0; index < deq.size(); index++)
{
//獲取位置爲 index 的元素
std::cout << deq.at(index) << " == "<< deq[index] << std::endl;
}
//使用迭代器訪問
std::deque<std::string>::reverse_iterator riter;
//如果是反向迭代器, 要全部是否反向迭代器 rbegin/ rend, 不能使用正向迭代器
for (riter = deq.rbegin(); riter != deq.rend(); riter++)
{
std::cout << *riter << std::endl;;
}
return 0;
}(5) deque 容器重置
#include <iostream>
#include <deque>
#include <algorithm>
#include <string>
int main()
{
std::deque<std::string> deq_a;
//首部插入元素
deq_a.push_front("Element 1");
//尾部插入元素
deq_a.push_back("Element 2");
std::deque<std::string> deq_b;
//重置容器b
deq_b.assign(deq_a.rbegin(), deq_a.rend());
//重置容器b
deq_b.assign(3, "Element 3");
return 0;
}(6) deque 容器內容交換
#include <iostream>
#include <deque>
#include <algorithm>
#include <string>
int main()
{
std::deque<std::string> deq_a;
//首部插入元素
deq_a.push_front("Element 1");
//尾部插入元素
deq_a.push_back("Element 2");
std::deque<std::string> deq_b;
//重置容器b
deq_b.assign(3, "Element 3");
//交換
deq_a.swap(deq_b);
//算法交換
std::swap(deq_a, deq_b);
return 0;
}(7) deque 容器的插入和刪除
#include <iostream>
#include <deque>
#include <algorithm>
#include <string>
void Output(char c)
{
std::cout << c << std::endl;
}
int main()
{
//容器初始化, 3個字符 'A'
std::deque<char> deq_char(3, 'A');
//首部插入1個元素, 'S'
deq_char.insert(deq_char.begin(), 'S');
//尾部插入5個元素, 'J'
deq_char.insert(deq_char.end(), 5, 'J');
//定義另一容器
std::deque<char> other_deq_char(5, 'P');
//首部插入新定義的一個容器
deq_char.insert(deq_char.begin(), other_deq_char.begin(), other_deq_char.end());
//輸出
std::for_each(deq_char.begin(), deq_char.end(), Output);//Output: PPPPPSAAAJJJJJ
//刪除首部第一個元素
deq_char.erase(deq_char.begin());
//刪除全部元素
deq_char.erase(deq_char.begin(), deq_char.end());
//重新插入元素
deq_char.insert(deq_char.begin(), other_deq_char.begin(), other_deq_char.end());
//刪除全部元素, 等同於 erase(begin(), end())
deq_char.clear();
return 0;
}(8) deque 容器的操作運算符
#include <iostream>
#include <deque>
#include <algorithm>
#include <string>
int main()
{
//deque 容器初始化
std::deque<int> deq_a(5, 0);
std::deque<int>::iterator iter = deq_a.begin();
for (int index = 0; index < 5; index++)
{
*iter = index;
iter++;
}
int num = 0;
//獲取第3個元素, value = 2
num = deq_a[2];
//獲取第4個元素, value = 3
num = deq_a[3];
bool result = false;
//判斷容器是否相等
std::deque<int> deq_b(5, 0);
// "==" 操作運算符, 判斷容器的內容是否完全相等, result = false
result = (deq_a == deq_b) ? true : false;
// "!=" 操作運算符, 判斷容器的內容是否不相等, result = true
result = (deq_a != deq_b) ? true : false;
// "<" 操作運算符, 容器的內容比對大小, result = false
result = (deq_a < deq_b) ? true : false;
// ">" 操作運算符, 容器的內容比對大小, result = true
result = (deq_a > deq_b) ? true : false;
deq_b.assign(deq_a.begin(), deq_a.end());
// "==" 操作運算符, 判斷容器的內容是否完全相等, result = true
result = (deq_a == deq_b) ? true : false;
// ">=" 操作運算符, 容器的內容比對大小, result = true
result = (deq_a >= deq_b) ? true : false;
// "<=" 操作運算符, 容器的內容比對大小, result = true
result = (deq_a <= deq_b) ? true : false;
return 0;
}至此，deque 容器就告一段落了，接下來將介紹List容器。
