std::deque是雙端隊列，可以高效的在頭尾兩端插入和刪除元素，在std::deque兩端插入和刪除並不會使其它元素的指針或引用失效。在接口上和std::vector相似。與sdk::vector相反，std::deque中的元素並非連續存儲：典型的實現是使用一個單獨分配的固定大小數組的序列。std::deque的存儲空間會自動按需擴大和縮小。擴大std::deque比擴大std::vector要便宜，因為它不涉及到現有元素復制到新的內存位置。
雙端隊列（Double-ended queue，縮寫為Deque）是一個大小可以動態變化（Dynamic size）且可以在兩端擴展或收縮的順序容器。順序容器中的元素按照嚴格的線性順序排序。可以通過元素在序列中的位置訪問對應的元素。不同的庫可能會按不同的方式來實現雙端隊列，通常實現為某種形式的動態數組。但不管通過哪種方式，雙端隊列都允許通過隨機迭代器直接訪問各個元素，且內部的存儲空間會按需求自動地擴展或收縮。容器實際分配的內存數超過容納當前所有有效元素所需的，因為額外的內存將被未來增長的部分所使用。就因為這點，當插入元素時，容器不需要太頻繁地分配內存。因此，雙端隊列提供了類似向量（std::vector）的功能，且不僅可以在容器末尾，還可以在容器開頭高效地插入或刪除元素。但是，相比向量，雙端隊列不保證內部的元素是按連續的存儲空間存儲的，因此，不允許對指針直接做偏移操作來直接訪問元素。在內部，雙端隊列與向量的工作方式完全不同：向量使用單數組數據結構，在元素增加的過程中，需要偶爾的內存重分配，而雙端隊列中的元素被零散地保存在不同的存儲塊中，容器內部會保存一些必要的數據使得可以以恆定時間及一個統一的順序接口直接訪問任意元素。因此，雙端隊列的內部實現比向量的稍稍復雜一點，但這也使得它在一些特定環境下可以更高效地增長，特別是對於非常長的序列，內存重分配的代價是及其高昂的。對於大量涉及在除了起始或末尾以外的其它任意位置插入或刪除元素的操作，相比列表（std::list）及正向列表（std::forward_list），deque 所表現出的性能是極差的，且操作前后的迭代器、引用的一致性較低。
A deque is very much like a vector: like vector, it is a sequence that supports random access to elements, constant time insertion and removal of elements at the end of these quence, and linear time insertion and removal of elements in the middle. The main way in which deque differs from vector is that deque also supports constant time insertion and removal of elements at the beginning of the sequence. Additionally, deque does not have any member functions analogous to vector's capacity() and reserve(), and does not provide any of the guarantees on iterator validity that are associated with those member functions.
一個容器就是一些特定類型對象的集合。順序容器(sequential container)為程序員提供了控制元素存儲和訪問順序的能力。這種順序不依賴於元素的值，而是與元素加入容器時的位置相對應。
標准庫中的順序容器包括：
(1)、vector：可變大小數組。支持快速隨機訪問。在尾部之外的位置插入或刪除元素可能很慢。
(2)、deque：雙端隊列。支持快速隨機訪問。在頭尾位置插入/刪除速度很快。
(3)、list：雙向鏈表。只支持雙向順序訪問。在list中任何位置進行插入/刪除操作速度都很快。
(4)、forward_list：單向鏈表。只支持單向順序訪問。在鏈表任何位置進行插入/刪除操作速度都很快。
(5)、array：固定大小數組。支持快速隨機訪問。不能添加或刪除元素。
(6)、string：與vector相似的容器，但專門用於保存字符。隨機訪問快。在尾部插入/刪除速度快。
除了固定大小的array外，其它容器都提供高效、靈活的內存管理。我們可以添加和刪除元素，擴張和收縮容器的大小。容器保存元素的策略對容器操作的效率有着固定的，有時是重大的影響。在某些情況下，存儲策略還會影響特定容器是否支持特定操作。
例如，string和vector將元素保存在連續的內存空間中。由於元素是連續存儲的，由元素的下標來計算其地址是非常快速的。但是，在這兩種容器的中間位置添加或刪除元素就會非常耗時：在一次插入或刪除操作后，需要移動插入/刪除位置之后的所有元素，來保持連續存儲。而且，添加一個元素有時可能還需要分配額外的存儲空間。在這種情況下，每個元素都必須移動到新的存儲空間中。
list和forward_list兩個容器的設計目的是令容器任何位置的添加和刪除操作都很快速。作為代價，這兩個容器不支持元素的隨機訪問：為了訪問一個元素，我們只能遍歷整個容器。而且，與vector、deque和array相比，這兩個容器的額外內存開銷也很大。
deque是一個更為復雜的數據結構。與string和vector類似，deque支持快速的隨機訪問。與string和vector一樣，在deque的中間位置添加或刪除元素的代價(可能)很高。但是，在deque的兩端添加或刪除元素都是很快的，與list或forward_list添加刪除元素的速度相當。
forward_list和array是新C++標准增加的類型。與內置數組相比，array是一個種更安全、更容易使用的數組類型。與內置數組類似，array對象的大小是固定的。因此，array不支持添加和刪除元素以及改變容器大小的操作。forward_list的設計目標是達到與最好的手寫的單向鏈表數據結構相當的性能。因此，forward_list沒有size操作，因為保存或計算其大小就會比手寫鏈表多出額外的開銷。對其他容器而言，size保證是一個快速的常量時間的操作。
通常，使用vector是最好的選擇，除法你有很好的理由選擇其他容器。
以下是一些選擇容器的基本原則：
(1)、除法你有很好的理由選擇其他容器，否則應該使用vector；
(2)、如果你的程序有很多小的元素，且空間的額外開銷很重要，則不要使用list或forward_list；
(3)、如果程序要求隨機訪問元素，應使用vector或deque；
(4)、如果程序要求在容器的中間插入或刪除元素，應使用list或forward_list；
(5)、如果程序需要在頭尾位置插入或刪除元素，但不會在中間位置進行插入或刪除操作，則使用deque；
(6)、如果程序只有在讀取輸入時才需要在容器中間位置插入元素，隨后需要隨機訪問元素，則：首先，確定是否真的需要在容器中間位置添加元素。當處理輸入數據時，通常可以很容器地向vector追加數據，然后再調用標准庫的sort函數來重排容器中的元素，從而避免在中間位置添加元素。如果必須在中間位置插入元素，考慮在輸入階段使用list，一旦輸入完成，將list中的內容拷貝到一個vector中。
如果你不確定應該使用哪種容器，那么可以在程序中只使用vector和list公共的操作：使用迭代器，不使用下標操作，避免隨機訪問。這樣，在必要時選擇使用vector或list都很方便。
一般來說，每個容器都定義在一個頭文件中，文件名與類型名相同。即，deque定義在頭文件deque中，list定義在頭文件list中，以此類推。容器均定義為模板類。
順序容器幾乎可以保存任意類型的元素。特別是，我們可以定義一個容器，其元素的類型是另一個容器。這種容器的定義與任何其他容器類型完全一樣：在尖括號中指定元素類型(此種情況下，是另一種容器類型)。
除了順序容器外，標准庫還定義了三個順序容器適配器：stack、queue和priority_queue。適配器(adaptor)是標准庫中的一個通用概念。容器、迭代器和函數都有適配器。本質上，一個適配器是一種機制，能使某種事物的行為看起來像另外一種事物一樣。一個容器適配器接受一種已有的容器類型，使其行為看起來像一種不同的類型。
下面是從其他文章中copy的測試代碼，詳細內容介紹可以參考對應的reference：
-
-
-
-
-
-
////////////////////////////////////////////////////////
-
// https://msdn.microsoft.com/en-us/library/22a9t119.aspx
-
int test_deque_2()
-
{
-
{ // deque::at: Returns a reference to the element at a specified location in the deque.
-
using namespace std;
-
deque <int> c1;
-
-
c1.push_back( 10);
-
c1.push_back( 20);
-
-
const int& i = c1.at(0);
-
int& j = c1.at(1);
-
cout << "The first element is " << i << endl;
-
cout << "The second element is " << j << endl;
-
}
-
-
{ // deque::back: Returns a reference to the last element of the deque.
-
using namespace std;
-
deque <int> c1;
-
-
c1.push_back( 10);
-
c1.push_back( 11);
-
-
int& i = c1.back();
-
const int& ii = c1.front();
-
-
cout << "The last integer of c1 is " << i << endl; // 11
-
i--;
-
cout << "The next-to-last integer of c1 is " << ii << endl; // 10
-
cout << "The last integer of c1 is " << c1.back() << endl; // 10
-
}
-
-
{ // deque::clear: Erases all the elements of a deque.
-
using namespace std;
-
deque <int> c1;
-
-
c1.push_back( 10);
-
c1.push_back( 20);
-
c1.push_back( 30);
-
-
cout << "The size of the deque is initially " << c1.size() << endl;
-
c1.clear();
-
cout << "The size of the deque after clearing is " << c1.size() << endl;
-
}
-
-
{ // deque::const_reference: A type that provides a reference to a const element stored in a deque for reading and performing const operations
-
using namespace std;
-
deque <int> c1;
-
-
c1.push_back( 10);
-
c1.push_back( 20);
-
-
const deque <int> c2 = c1;
-
const int &i = c2.front();
-
const int &j = c2.back();
-
cout << "The first element is " << i << endl;
-
cout << "The second element is " << j << endl;
-
-
// The following line would cause an error as c2 is const
-
// c2.push_back( 30 );
-
}
-
-
{ // deque::crbegin: Returns a const iterator to the first element in a reversed deque
-
using namespace std;
-
deque <int> v1;
-
deque <int>::iterator v1_Iter;
-
deque <int>::const_reverse_iterator v1_rIter;
-
-
v1.push_back( 1);
-
v1.push_back( 2);
-
-
v1_Iter = v1.begin();
-
cout << "The first element of deque is "
-
<< *v1_Iter << "." << endl;
-
-
v1_rIter = v1.crbegin();
-
cout << "The first element of the reversed deque is "
-
<< *v1_rIter << "." << endl;
-
}
-
-
{ // deque::emplace: Inserts an element constructed in place into the deque at a specified position.
-
using namespace std;
-
deque <int> v1;
-
deque <int>::iterator Iter;
-
-
v1.push_back( 10);
-
v1.push_back( 20);
-
v1.push_back( 30);
-
-
cout << "v1 =";
-
for (Iter = v1.begin(); Iter != v1.end(); Iter++)
-
cout << " " << *Iter;
-
cout << endl;
-
-
// initialize a deque of deques by moving v1
-
deque < deque <int> > vv1;
-
-
vv1.emplace(vv1.begin(), move(v1));
-
if (vv1.size() != 0 && vv1[0].size() != 0) {
-
cout << "vv1[0] =";
-
for (Iter = vv1[0].begin(); Iter != vv1[0].end(); Iter++)
-
cout << " " << *Iter;
-
cout << endl;
-
}
-
}
-
-
return 0;
-
}
-
-
/////////////////////////////////////////////////////////////
-
// reference: http://www.cplusplus.com/reference/deque/deque/
-
int test_deque_1()
-
{
-
{ // deque::deque: Construct deque container
-
unsigned int i;
-
-
// constructors used in the same order as described above:
-
std::deque<int> first; // empty deque of ints
-
std::deque<int> second(4, 100); // four ints with value 100
-
std::deque<int> third(second.begin(), second.end()); // iterating through second
-
std::deque<int> fourth(third); // a copy of third
-
-
// the iterator constructor can be used to copy arrays:
-
int myints[] = { 16, 2, 77, 29 };
-
std::deque<int> fifth(myints, myints + sizeof(myints) / sizeof(int));
-
-
std::cout << "The contents of fifth are:";
-
for (std::deque<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
-
std::cout << ' ' << *it; // 16 2 77 29
-
std::cout << '\n';
-
}
-
-
{ // deque::assign: Assigns new contents to the deque container,
-
// replacing its current contents, and modifying its size accordingly.
-
-
std::deque<int> first;
-
std::deque<int> second;
-
std::deque<int> third;
-
-
first.assign( 7, 100); // 7 ints with a value of 100
-
-
std::deque<int>::iterator it;
-
it = first.begin() + 1;
-
-
second.assign(it, first.end() - 1); // the 5 central values of first
-
-
int myints[] = { 1776, 7, 4 };
-
third.assign(myints, myints + 3); // assigning from array.
-
-
std::cout << "Size of first: " << int(first.size()) << '\n'; // 7
-
std::cout << "Size of second: " << int(second.size()) << '\n'; // 5
-
std::cout << "Size of third: " << int(third.size()) << '\n'; // 3
-
}
-
-
{ // deque::at: Returns a reference to the element at position n in the deque container object.
-
std::deque<unsigned> mydeque(10); // 10 zero-initialized unsigneds
-
-
// assign some values:
-
for (unsigned i = 0; i < mydeque.size(); i++)
-
mydeque.at(i) = i;
-
-
std::cout << "mydeque contains:";
-
for (unsigned i = 0; i < mydeque.size(); i++)
-
std::cout << ' ' << mydeque.at(i); // 0 1 2 3 4 5 6 7 8 9
-
std::cout << '\n';
-
}
-
-
{ // deque::back: Returns a reference to the last element in the container.
-
// deque::push_back: Adds a new element at the end of the deque container,
-
// after its current last element. The content of val is copied (or moved) to the new element
-
std::deque<int> mydeque;
-
mydeque.push_back( 10);
-
-
while (mydeque.back() != 0)
-
mydeque.push_back(mydeque.back() - 1);
-
-
std::cout << "mydeque contains:";
-
for (std::deque<int>::iterator it = mydeque.begin(); it != mydeque.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
{ // deque::begin: Return iterator to beginning
-
// deque::end: Return iterator to end
-
std::deque<int> mydeque;
-
for (int i = 1; i <= 5; i++) mydeque.push_back(i);
-
-
std::cout << "mydeque contains:";
-
std::deque<int>::iterator it = mydeque.begin();
-
-
while (it != mydeque.end())
-
std::cout << ' ' << *it++;
-
std::cout << '\n';
-
}
-
-
{ // deque::cbegin: c++11, Return const_iterator to beginning
-
// deque::cend: c++11, Return const_iterator to end
-
std::deque<int> mydeque = { 10, 20, 30, 40, 50 };
-
-
std::cout << "mydeque contains:";
-
for (auto it = mydeque.cbegin(); it != mydeque.cend(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
{ // deque::clear: Clear content
-
unsigned int i;
-
std::deque<int> mydeque;
-
mydeque.push_back( 100);
-
mydeque.push_back( 200);
-
mydeque.push_back( 300);
-
-
std::cout << "mydeque contains:";
-
for (std::deque<int>::iterator it = mydeque.begin(); it != mydeque.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
-
mydeque.clear();
-
mydeque.push_back( 1101);
-
mydeque.push_back( 2202);
-
-
std::cout << "mydeque contains:";
-
for (std::deque<int>::iterator it = mydeque.begin(); it != mydeque.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
{ // deque::crbegin: c++11, Return const_reverse_iterator to reverse beginning
-
// deque::crend: c++11, Return const_reverse_iterator to reverse end
-
std::deque<int> mydeque = { 1, 2, 3, 4, 5 };
-
-
std::cout << "mydeque backwards:";
-
for (auto rit = mydeque.crbegin(); rit != mydeque.crend(); ++rit)
-
std::cout << ' ' << *rit;
-
std::cout << '\n';
-
}
-
-
{ // deque::emplace: c++11, Construct and insert element
-
std::deque<int> mydeque = { 10, 20, 30 };
-
-
auto it = mydeque.emplace(mydeque.begin() + 1, 100);
-
mydeque.emplace(it, 200);
-
mydeque.emplace(mydeque.end(), 300);
-
-
std::cout << "mydeque contains:";
-
for (auto& x : mydeque)
-
std::cout << ' ' << x;
-
std::cout << '\n';
-
}
-
-
{ // deque::emplace_back: c++11, Construct and insert element at the end
-
std::deque<int> mydeque = { 10, 20, 30 };
-
-
mydeque.emplace_back( 100);
-
mydeque.emplace_back( 200);
-
-
std::cout << "mydeque contains:";
-
for (auto& x : mydeque)
-
std::cout << ' ' << x;
-
std::cout << '\n';
-
}
-
-
{ // deque::emplace_front: c++11, Construct and insert element at beginning
-
std::deque<int> mydeque = { 10, 20, 30 };
-
-
mydeque.emplace_front( 111);
-
mydeque.emplace_front( 222);
-
-
std::cout << "mydeque contains:";
-
for (auto& x : mydeque)
-
std::cout << ' ' << x;
-
std::cout << '\n';
-
}
-
-
{ // deque::empty: Test whether container is empty
-
std::deque<int> mydeque;
-
int sum(0);
-
-
for (int i = 1; i <= 10; i++) mydeque.push_back(i);
-
-
while (!mydeque.empty()) {
-
sum += mydeque.front();
-
mydeque.pop_front();
-
}
-
-
std::cout << "total: " << sum << '\n';
-
}
-
-
{ // deque::erase: Erase elements
-
std::deque<int> mydeque;
-
-
// set some values (from 1 to 10)
-
for (int i = 1; i <= 10; i++) mydeque.push_back(i);
-
-
// erase the 6th element
-
mydeque.erase(mydeque.begin() + 5);
-
-
// erase the first 3 elements:
-
mydeque.erase(mydeque.begin(), mydeque.begin() + 3);
-
-
std::cout << "mydeque contains:";
-
for (std::deque<int>::iterator it = mydeque.begin(); it != mydeque.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
{ // deque::front: Access first element, Returns a reference to the first element in the deque containe
-
// deque::push_front: Inserts a new element at the beginning of the deque container,
-
// right before its current first element. The content of val is copied (or moved) to the inserted element
-
std::deque<int> mydeque;
-
-
mydeque.push_front( 77);
-
mydeque.push_back( 20);
-
-
mydeque.front() -= mydeque.back();
-
-
std::cout << "mydeque.front() is now " << mydeque.front() << '\n';
-
}
-
-
{ // deque::get_allocator: Returns a copy of the allocator object associated with the deque object
-
std::deque<int> mydeque;
-
int * p;
-
unsigned int i;
-
-
// allocate an array with space for 5 elements using deque's allocator:
-
p = mydeque.get_allocator().allocate( 5);
-
-
// construct values in-place on the array:
-
for (i = 0; i < 5; i++) mydeque.get_allocator().construct(&p[i], i);
-
-
std::cout << "The allocated array contains:";
-
for (i = 0; i < 5; i++) std::cout << ' ' << p[i];
-
std::cout << '\n';
-
-
// destroy and deallocate:
-
for (i = 0; i < 5; i++) mydeque.get_allocator().destroy(&p[i]);
-
mydeque.get_allocator().deallocate(p, 5);
-
}
-
-
{ // deque::insert: Insert elements
-
std::deque<int> mydeque;
-
-
// set some initial values:
-
for (int i = 1; i < 6; i++) mydeque.push_back(i); // 1 2 3 4 5
-
-
std::deque<int>::iterator it = mydeque.begin();
-
++it;
-
-
it = mydeque.insert(it, 10); // 1 10 2 3 4 5
-
// "it" now points to the newly inserted 10
-
-
mydeque.insert(it, 2, 20); // 1 20 20 10 2 3 4 5
-
// "it" no longer valid!
-
-
it = mydeque.begin() + 2;
-
-
std::vector<int> myvector(2, 30);
-
mydeque.insert(it, myvector.begin(), myvector.end());
-
// 1 20 30 30 20 10 2 3 4 5
-
-
std::cout << "mydeque contains:";
-
for (it = mydeque.begin(); it != mydeque.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
{ // deque::max_size: Return maximum size
-
unsigned int i;
-
std::deque<int> mydeque;
-
-
std::cout << "Enter number of elements: ";
-
i = 100; //std::cin >> i;
-
-
if (i < mydeque.max_size()) mydeque.resize(i);
-
else std::cout << "That size exceeds the limit.\n";
-
fprintf(stderr, "max size: %d\n", mydeque.max_size());
-
}
-
-
{ // deque::operator=: Assigns new contents to the container, replacing its current contents, and modifying its size accordingly
-
std::deque<int> first(3); // deque with 3 zero-initialized ints
-
std::deque<int> second(5); // deque with 5 zero-initialized ints
-
-
second = first;
-
first = std::deque<int>();
-
-
std::cout << "Size of first: " << int(first.size()) << '\n';
-
std::cout << "Size of second: " << int(second.size()) << '\n';
-
}
-
-
{ // deque::operator[]: Returns a reference to the element at position n in the deque container
-
std::deque<int> mydeque(10); // 10 zero-initialized elements
-
std::deque<int>::size_type sz = mydeque.size();
-
-
// assign some values:
-
for (unsigned i = 0; i < sz; i++) mydeque[i] = i;
-
-
// reverse order of elements using operator[]:
-
for (unsigned i = 0; i < sz / 2; i++) {
-
int temp;
-
temp = mydeque[sz - 1 - i];
-
mydeque[sz - 1 - i] = mydeque[i];
-
mydeque[i] = temp;
-
}
-
-
// print content:
-
std::cout << "mydeque contains:";
-
for (unsigned i = 0; i < sz; i++)
-
std::cout << ' ' << mydeque[i];
-
std::cout << '\n';
-
}
-
-
{ // deque::pop_back: Removes the last element in the deque container, effectively reducing the container size by one
-
std::deque<int> mydeque;
-
int sum(0);
-
mydeque.push_back( 10);
-
mydeque.push_back( 20);
-
mydeque.push_back( 30);
-
-
while (!mydeque.empty()) {
-
sum += mydeque.back();
-
mydeque.pop_back();
-
}
-
-
std::cout << "The elements of mydeque add up to " << sum << '\n';
-
}
-
-
{ // deque::pop_front: Removes the first element in the deque container, effectively reducing its size by one.
-
std::deque<int> mydeque;
-
-
mydeque.push_back( 100);
-
mydeque.push_back( 200);
-
mydeque.push_back( 300);
-
-
std::cout << "Popping out the elements in mydeque:";
-
while (!mydeque.empty()) {
-
std::cout << ' ' << mydeque.front();
-
mydeque.pop_front();
-
}
-
-
std::cout << "\nThe final size of mydeque is " << int(mydeque.size()) << '\n';
-
}
-
-
{ // deque::rbegin: Returns a reverse iterator pointing to the last element in the container
-
// deque::rend: Returns a reverse iterator pointing to the theoretical element preceding the first element in the deque container
-
std::deque<int> mydeque(5); // 5 default-constructed ints
-
-
std::deque<int>::reverse_iterator rit = mydeque.rbegin();
-
-
int i = 0;
-
for (rit = mydeque.rbegin(); rit != mydeque.rend(); ++rit)
-
*rit = ++i;
-
-
std::cout << "mydeque contains:";
-
for (std::deque<int>::iterator it = mydeque.begin(); it != mydeque.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
{ // deque::resize: Resizes the container so that it contains n elements
-
std::deque<int> mydeque;
-
std::deque<int>::iterator it;
-
-
// set some initial content:
-
for (int i = 1; i < 10; ++i) mydeque.push_back(i);
-
-
mydeque.resize( 5);
-
mydeque.resize( 8, 100);
-
mydeque.resize( 12);
-
-
std::cout << "mydeque contains:";
-
for (std::deque<int>::iterator it = mydeque.begin(); it != mydeque.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
{ // deque::shrink_to_fit: c++11, Requests the container to reduce its memory usage to fit its size.
-
// deque::size: Returns the number of elements in the deque container
-
std::deque<int> mydeque(100);
-
std::cout << "1. size of mydeque: " << mydeque.size() << '\n';
-
-
mydeque.resize( 10);
-
std::cout << "2. size of mydeque: " << mydeque.size() << '\n';
-
-
mydeque.shrink_to_fit();
-
fprintf(stderr, "3. size of mydeque: %d\n", mydeque.size());
-
}
-
-
{ // deque::swap: Exchanges the content of the container by the content of x,
-
// which is another deque object containing elements of the same type. Sizes may differ.
-
unsigned int i;
-
std::deque<int> foo(3, 100); // three ints with a value of 100
-
std::deque<int> bar(5, 200); // five ints with a value of 200
-
-
foo.swap(bar);
-
-
std::cout << "foo contains:";
-
for (std::deque<int>::iterator it = foo.begin(); it != foo.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
-
std::cout << "bar contains:";
-
for (std::deque<int>::iterator it = bar.begin(); it != bar.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
{ // relational operators: compare
-
std::deque<int> foo(3, 100); // three ints with a value of 100
-
std::deque<int> bar(2, 200); // two ints with a value of 200
-
-
if (foo == bar) std::cout << "foo and bar are equal\n";
-
if (foo != bar) std::cout << "foo and bar are not equal\n";
-
if (foo< bar) std::cout << "foo is less than bar\n";
-
if (foo> bar) std::cout << "foo is greater than bar\n";
-
if (foo <= bar) std::cout << "foo is less than or equal to bar\n";
-
if (foo >= bar) std::cout << "foo is greater than or equal to bar\n";
-
}
-
-
{ // std::swap: The contents of container x are exchanged with those of y.
-
// Both container objects must be of the same type (same template parameters), although sizes may differ
-
unsigned int i;
-
std::deque<int> foo(3, 100); // three ints with a value of 100
-
std::deque<int> bar(5, 200); // five ints with a value of 200
-
-
swap(foo, bar);
-
-
std::cout << "foo contains:";
-
for (std::deque<int>::iterator it = foo.begin(); it != foo.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
-
std::cout << "bar contains:";
-
for (std::deque<int>::iterator it = bar.begin(); it != bar.end(); ++it)
-
std::cout << ' ' << *it;
-
std::cout << '\n';
-
}
-
-
return 0;
-
}