deque (STL/CLR)
樣板類別描述一個物件，控制具有隨機存取權之專案的不同長度序列。 您可以使用容器 deque 來管理一連串看起來像連續儲存體區塊的專案，但兩端都可以成長或縮小，而不需要複製任何剩餘的元素。 因此，它可以有效率地實作 double-ended queue 。 （因此，名稱。）
在下列描述中， GValue 除非後者是 ref 型別，否則 Value^ 會是 Value 。
語法
template<typename Value>
ref class deque
: public
System::ICloneable,
System::Collections::IEnumerable,
System::Collections::ICollection,
System::Collections::Generic::IEnumerable<GValue>,
System::Collections::Generic::ICollection<GValue>,
System::Collections::Generic::IList<GValue>,
Microsoft::VisualC::StlClr::IDeque<GValue>
{ ..... };
參數
GValue
受控制序列中專案的泛型型別。
值
受控制序列中項目的類型。
需求
標頭： < cliext/deque>
命名空間： cliext
宣告
| 類型定義 | 描述 |
|---|---|
| deque::const_iterator (STL/CLR) | 用於受控制序列的常數迭代器類型。 |
| deque::const_reference (STL/CLR) | 項目的常數參考類型。 |
| deque::const_reverse_iterator (STL/CLR) | 用於受控制序列的常數反向迭代器類型。 |
| deque::difference_type (STL/CLR) | 兩個項目之間帶正負號距離的類型。 |
| deque::generic_container (STL/CLR) | 容器之泛型介面的類型。 |
| deque::generic_iterator (STL/CLR) | 容器之泛型介面的反覆運算器類型。 |
| deque::generic_reverse_iterator (STL/CLR) | 容器之泛型介面的反向反覆運算器類型。 |
| deque::generic_value (STL/CLR) | 容器之泛型介面的專案型別。 |
| deque::iterator (STL/CLR) | 受控制序列之迭代器的類型。 |
| deque::reference (STL/CLR) | 項目的參考類型。 |
| deque::reverse_iterator (STL/CLR) | 受控制序列的反向迭代器類型。 |
| deque::size_type (STL/CLR) | 兩個項目之間帶正負號距離的類型。 |
| deque::value_type (STL/CLR) | 元素的類型。 |
| 成員函式 | 描述 |
|---|---|
| deque::assign (STL/CLR) | 取代所有項目。 |
| deque::at (STL/CLR) | 存取指定位置的項目。 |
| deque::back (STL/CLR) | 存取最後一個項目。 |
| deque::begin (STL/CLR) | 指定受控制序列的開頭。 |
| deque::clear (STL/CLR) | 移除所有項目。 |
| deque::deque (STL/CLR) | 建構容器物件。 |
| deque::empty (STL/CLR) | 測試項目是否不存在。 |
| deque::end (STL/CLR) | 指定受控制序列的結尾。 |
| deque::erase (STL/CLR) | 移除位於指定位置的項目。 |
| deque::front (STL/CLR) | 存取第一個項目。 |
| deque::insert (STL/CLR) | 在指定的位置加入專案。 |
| deque::pop_back (STL/CLR) | 移除最後一個專案。 |
| deque::pop_front (STL/CLR) | 移除第一個專案。 |
| deque::push_back (STL/CLR) | 加入新的最後一個專案。 |
| deque::push_front (STL/CLR) | 加入新的第一個專案。 |
| deque::rbegin (STL/CLR) | 指定反向受控制序列的開頭。 |
| deque::rend (STL/CLR) | 指定反向受控制序列的結尾。 |
| deque::resize (STL/CLR) | 變更專案數目。 |
| deque::size (STL/CLR) | 計算元素的數目。 |
| deque::swap (STL/CLR) | 交換兩個容器的內容。 |
| deque::to_array (STL/CLR) | 將受控制序列複製到新的陣列。 |
| 屬性 | 說明 |
|---|---|
| deque::back_item (STL/CLR) | 存取最後一個項目。 |
| deque::front_item (STL/CLR) | 存取第一個項目。 |
| 運算子 | 描述 |
|---|---|
| deque::operator!= (STL/CLR) | 判斷兩個 deque 物件是否不相等。 |
| deque::operator (STL/CLR) | 存取指定位置的項目。 |
| 運算子 < （deque） （STL/CLR） | 判斷物件是否 deque 小於另一個 deque 物件。 |
| operator < = （deque） （STL/CLR） | 判斷物件是否 deque 小於或等於另一個 deque 物件。 |
| operator= (deque) (STL/CLR) | 取代受控制的序列。 |
| operator== (deque) (STL/CLR) | 判斷物件是否 deque 等於另一個 deque 物件。 |
| 運算子 > （deque） （STL/CLR） | 判斷物件是否 deque 大於另一個 deque 物件。 |
| operator > = （deque） （STL/CLR） | 判斷物件是否 deque 大於或等於另一個 deque 物件。 |
介面
| 介面 | 描述 |
|---|---|
| ICloneable | 複製 物件。 |
| IEnumerable | 循序通過元素。 |
| ICollection | 維護專案群組。 |
| IEnumerable<T> | 透過具型別的元素進行排序。 |
| ICollection<T> | 維護具型別專案的群組。 |
| IList<T> | 維護具型別專案的已排序群組。 |
| IDeque < 值> | 維護泛型容器。 |
備註
物件會透過指定元素區塊的 Value 預存控制碼陣列，為它所控制的順序配置和釋放儲存空間。 陣列會隨選成長。 成長會以這樣的方式發生，使預先加上或附加新元素的成本是固定的時間，而且不會干擾剩餘的專案。 您也可以在常數時間的任一端移除元素，而不幹擾其餘元素。 因此，deque 是範本類別 佇列基礎容器 （STL/CLR） 或範本類別 堆疊 （STL/CLR） 的良好候選項目。
deque物件支援隨機存取反覆運算器，這表示您可以直接參考元素的數值位置，從第一個 （front） 元素的零計算為 deque：：size （STL/CLR） 最後一個 （back） () - 1 元素。 這也表示 deque 是範本類別 的基礎容器priority_queue （STL/CLR） 的良好候選項目。
deque 反覆運算器會儲存其相關聯 deque 物件的控制碼，以及它所指定之元素的偏差。 您只能搭配其相關聯的容器物件使用反覆運算器。 deque 元素 的偏差不 一定與其位置相同。 插入的第一個元素有偏差零，下一個附加元素有偏差 1，但下一個前置元素有偏差 -1。
在任一端插入或清除專案並不會 改變儲存在任何有效偏差的專案值。 不過 ，插入或清除內部元素可以 變更儲存在指定偏差處的專案值，因此反覆運算器所指定的值也可以變更。 （容器可能需要向上或向下複製元素，才能在插入之前建立一個洞，或在清除後填滿洞。不過，只要 deque 反覆運算器的偏差指定有效的元素，deque 反覆運算器就仍然有效。 此外，有效的反覆運算器仍可取值-- 您可以使用它來存取或改變它指定的元素值 -- 只要其偏差不等於 所 end() 傳回之反覆運算器的偏差。
清除或移除專案會呼叫其預存值的解構函式。 終結容器會清除所有元素。 因此，元素類型為 ref 類別的容器可確保容器沒有元素超過該容器。 不過請注意，控制碼的容器不會 終結其元素。
成員
deque::assign (STL/CLR)
取代所有項目。
語法
void assign(size_type count, value_type val);
template<typename InIt>
void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);
參數
計數
要插入的元素數目。
first
要插入的範圍開頭。
last
要插入的範圍結尾。
right
要插入的列舉。
val
要插入的專案值。
備註
第一個成員函式會以重複 value val 的 count 元素取代受控制序列 。 您可以使用它來填滿容器，其中所有元素都有相同的值。
如果 InIt 是整數類型，則第二個成員函式的行為與 assign((size_type)first, (value_type)last) 相同。 否則，它會以序列 [ first ， last ] 取代受控制序列 。 您可以使用它讓受控制序列成為另一個序列的複本。
第三個成員函式會將受控制序列取代為列舉值 右邊 所指定的序列。 您可以使用它，讓受控制序列成為列舉值所描述之序列的複本。
範例
// cliext_deque_assign.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// assign a repetition of values
cliext::deque<wchar_t> c2;
c2.assign(6, L'x');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign an iterator range
c2.assign(c1.begin(), c1.end() - 1);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign an enumeration
c2.assign( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
x x x x x x
a b
a b c
deque::at (STL/CLR)
存取指定位置的項目。
語法
reference at(size_type pos);
參數
pos
要存取的項目的位置。
備註
成員函式會傳回位於位置 位置位置 之受控制序列專案的參考。您可以使用它來讀取或寫入您知道其位置的專案。
範例
// cliext_deque_at.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" using at
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1.at(i));
System::Console::WriteLine();
// change an entry and redisplay
c1.at(1) = L'x';
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1[i]);
System::Console::WriteLine();
return (0);
}
a b c
a x c
deque::back (STL/CLR)
存取最後一個項目。
語法
reference back();
備註
成員函式會傳回受控制序列最後一個專案的參考，該元素必須是非空白的。 當您知道它存在時，您可以使用它來存取最後一個專案。
範例
// cliext_deque_back.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last item
System::Console::WriteLine("back() = {0}", c1.back());
// alter last item and reinspect
c1.back() = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
back() = c
a b x
deque::back_item (STL/CLR)
存取最後一個項目。
語法
property value_type back_item;
備註
屬性會存取受控制序列的最後一個專案，該元素必須是非空白的。 當您知道它存在時，您可以使用它來讀取或寫入最後一個專案。
範例
// cliext_deque_back_item.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last item
System::Console::WriteLine("back_item = {0}", c1.back_item);
// alter last item and reinspect
c1.back_item = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
back_item = c
a b x
deque::begin (STL/CLR)
指定受控制序列的開頭。
語法
iterator begin();
備註
成員函式會傳回隨機存取反覆運算器，指定受控制序列的第一個專案，或剛好超出空序列結尾。 您可以使用它來取得指定 current 受控制序列開頭的反覆運算器，但如果受控制序列的長度變更，其狀態可能會變更。
範例
// cliext_deque_begin.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
cliext::deque<wchar_t>::iterator it = c1.begin();
System::Console::WriteLine("*begin() = {0}", *it);
System::Console::WriteLine("*++begin() = {0}", *++it);
// alter first two items and reinspect
*--it = L'x';
*++it = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*begin() = a
*++begin() = b
x y c
deque::clear (STL/CLR)
移除所有項目。
語法
void clear();
備註
成員函式有效地呼叫 deque：：erase （STL/CLR） ( deque：：begin （STL/CLR） (), deque：：end （STL/CLR） ()) 。 您可以使用它來確保受控制序列是空的。
範例
// cliext_deque_clear.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
// add elements and clear again
c1.push_back(L'a');
c1.push_back(L'b');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
a b c
size() = 0
a b
size() = 0
deque::const_iterator (STL/CLR)
用於受控制序列的常數迭代器類型。
語法
typedef T2 const_iterator;
備註
此類型描述未指定類型的 T2 物件，該物件可作為受控制序列的常數隨機存取反覆運算器。
範例
// cliext_deque_const_iterator.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
cliext::deque<wchar_t>::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
System::Console::Write("{0} ", *cit);
System::Console::WriteLine();
return (0);
}
a b c
deque::const_reference (STL/CLR)
項目的常數參考類型。
語法
typedef value_type% const_reference;
備註
此類型描述專案的常數參考。
範例
// cliext_deque_const_reference.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
cliext::deque<wchar_t>::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
{ // get a const reference to an element
cliext::deque<wchar_t>::const_reference cref = *cit;
System::Console::Write("{0} ", cref);
}
System::Console::WriteLine();
return (0);
}
a b c
deque::const_reverse_iterator (STL/CLR)
受控制序列的常數反向反覆運算器類型。
語法
typedef T4 const_reverse_iterator;
備註
此類型描述未指定型 T4 別的物件，該物件可作為受控制序列的常數反向反覆運算器。
範例
// cliext_deque_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" reversed
cliext::deque<wchar_t>::const_reverse_iterator crit = c1.rbegin();
cliext::deque<wchar_t>::const_reverse_iterator crend = c1.rend();
for (; crit != crend; ++crit)
System::Console::Write("{0} ", *crit);
System::Console::WriteLine();
return (0);
}
c b a
deque::deque (STL/CLR)
建構容器物件。
語法
deque();
deque(deque<Value>% right);
deque(deque<Value>^ right);
explicit deque(size_type count);
deque(size_type count, value_type val);
template<typename InIt>
deque(InIt first, InIt last);
deque(System::Collections::Generic::IEnumerable<Value>^ right);
參數
計數
要插入的元素數目。
first
要插入的範圍開頭。
last
要插入的範圍結尾。
right
要插入的物件或範圍。
val
要插入的專案值。
備註
建構函式：
deque();
初始化沒有元素的受控制序列。 您可以使用它來指定空的初始控制序列。
建構函式：
deque(deque<Value>% right);
使用序列 [， right.end() 來初始化受控制序列 。 right.begin() 您可以使用它來指定初始受控制序列，這是 deque 物件 右邊 所控制之序列的複本。 如需反覆運算器的詳細資訊，請參閱 deque：：begin （STL/CLR） 和 deque：：end （STL/CLR） 。
建構函式：
deque(deque<Value>^ right);
使用序列 [， right->end() 來初始化受控制序列 。 right->begin() 您可以使用它來指定初始受控制序列，這是由 deque 物件控制且控制碼 正確 之序列的複本。
建構函式：
explicit deque(size_type count);
初始化受控制序列，其 計數 專案各具有值 value_type() 。 您可以使用它來將容器填入所有具有預設值的專案。
建構函式：
deque(size_type count, value_type val);
使用具有 value val 的每個計數 元素，初始化受控制序列 。 您可以使用它來填滿容器，其中所有元素都有相同的值。
建構函式：
template<typename InIt>
deque(InIt first, InIt last);
使用序列 [， last 來初始化受控制序列 。 first 您可以使用它讓受控制序列成為另一個序列的複本。
建構函式：
deque(System::Collections::Generic::IEnumerable<Value>^ right);
使用列舉值 右邊 所指定的序列，初始化受控制序列。 您可以使用它讓受控制序列成為列舉值所描述之另一個序列的複本。
範例
// cliext_deque_construct.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
// construct an empty container
cliext::deque<wchar_t> c1;
System::Console::WriteLine("size() = {0}", c1.size());
// construct with a repetition of default values
cliext::deque<wchar_t> c2(3);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", (int)elem);
System::Console::WriteLine();
// construct with a repetition of values
cliext::deque<wchar_t> c3(6, L'x');
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an iterator range
cliext::deque<wchar_t>::iterator it = c3.end();
cliext::deque<wchar_t> c4(c3.begin(), --it);
for each (wchar_t elem in c4)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an enumeration
cliext::deque<wchar_t> c5( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
for each (wchar_t elem in c5)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying another container
cliext::deque<wchar_t> c7(c3);
for each (wchar_t elem in c7)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying a container handle
cliext::deque<wchar_t> c8(%c3);
for each (wchar_t elem in c8)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x
deque::difference_type (STL/CLR)
兩個專案之間帶正負號距離的類型。
語法
typedef int difference_type;
備註
此類型描述帶正負號的專案計數。
範例
// cliext_deque_difference_type.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
cliext::deque<wchar_t>::difference_type diff = 0;
for (cliext::deque<wchar_t>::iterator it = c1.begin();
it != c1.end(); ++it) ++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
// compute negative difference
diff = 0;
for (cliext::deque<wchar_t>::iterator it = c1.end();
it != c1.begin(); --it) --diff;
System::Console::WriteLine("begin()-end() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
begin()-end() = -3
deque::empty (STL/CLR)
測試項目是否不存在。
語法
bool empty();
備註
成員函式會對空的受控制序列傳回 true。 它相當於 deque：：size （STL/CLR） () == 0 。 您可以使用它來測試 deque 是否為空白。
範例
// cliext_deque_empty.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
return (0);
}
a b c
size() = 3
empty() = False
size() = 0
empty() = True
deque::end (STL/CLR)
指定受控制序列的結尾。
語法
iterator end();
備註
成員函式會傳回隨機存取反覆運算器，指向受控制序列結尾以外的點。 您可以使用它來取得指定 current 受控制序列結尾的反覆運算器，但如果受控制序列的長度變更，其狀態可能會變更。
範例
// cliext_deque_end.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last two items
cliext::deque<wchar_t>::iterator it = c1.end();
--it;
System::Console::WriteLine("*-- --end() = {0}", *--it);
System::Console::WriteLine("*--end() = {0}", *++it);
// alter first two items and reinspect
*--it = L'x';
*++it = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*-- --end() = b
*--end() = c
a x y
deque::erase (STL/CLR)
移除位於指定位置的項目。
語法
iterator erase(iterator where);
iterator erase(iterator first, iterator last);
參數
first
要清除的範圍開頭。
last
要清除的範圍結尾。
where
要清除的專案。
備註
第一個成員函式會移除所指向 之受控制序列的 元素。 您可以使用它來移除單一元素。
第二個成員函式會移除 [first, last) 範圍中受控制序列中的元素。 您可以使用它來移除零個或多個連續元素。
這兩個成員函式都會傳回反覆運算器，指定移除任何元素以外的第一個元素， 如果沒有這類專案，則為 deque：：end （STL/CLR）。 ()
清除專案時，元素複本數目在清除結尾與序列結尾之間的元素數目中是線性的。 （在序列的任一端清除一或多個元素時，不會發生任何元素複製。
範例
// cliext_deque_erase.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// erase an element and reinspect
System::Console::WriteLine("erase(begin()) = {0}",
*c1.erase(c1.begin()));
// add elements and display " b c d e"
c1.push_back(L'd');
c1.push_back(L'e');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// erase all but end
cliext::deque<wchar_t>::iterator it = c1.end();
System::Console::WriteLine("erase(begin(), end()-1) = {0}",
*c1.erase(c1.begin(), --it));
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1
deque::front (STL/CLR)
存取第一個項目。
語法
reference front();
備註
成員函式會傳回受控制序列第一個專案的參考，該元素必須是非空白的。 當您知道它存在時，您可以使用它來讀取或寫入第一個元素。
範例
// cliext_deque_front.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first item
System::Console::WriteLine("front() = {0}", c1.front());
// alter first item and reinspect
c1.front() = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
front() = a
x b c
deque::front_item (STL/CLR)
存取第一個項目。
語法
property value_type front_item;
備註
屬性會存取受控制序列的第一個專案，該元素必須是非空白的。 當您知道它存在時，您可以使用它來讀取或寫入第一個元素。
範例
// cliext_deque_front_item.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first item
System::Console::WriteLine("front_item = {0}", c1.front_item);
// alter first item and reinspect
c1.front_item = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
front_item = a
x b c
deque::generic_container (STL/CLR)
容器之泛型介面的類型。
語法
typedef Microsoft::VisualC::StlClr::
IDeque<generic_value>
generic_container;
備註
此類型描述此範本容器類別的泛型介面。
範例
// cliext_deque_generic_container.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
gc1->insert(gc1->end(), L'd');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify original and display generic
c1.push_back(L'e');
System::Collections::IEnumerator^ enum1 =
gc1->GetEnumerator();
while (enum1->MoveNext())
System::Console::Write("{0} ", enum1->Current);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a b c d
a b c d e
deque::generic_iterator (STL/CLR)
用於容器之泛型介面的反覆運算器類型。
語法
typedef Microsoft::VisualC::StlClr::Generic::
ContainerRandomAccessIterator<generic_value> generic_iterator;
備註
此類型描述可搭配此範本容器類別之泛型介面使用的泛型反覆運算器。
範例
// cliext_deque_generic_iterator.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
cliext::deque<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a a c
deque::generic_reverse_iterator (STL/CLR)
用於容器之泛型介面的反向反覆運算器類型。
語法
typedef Microsoft::VisualC::StlClr::Generic::
ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;
備註
此類型描述可搭配此範本容器類別之泛型介面使用的泛型反向反覆運算器。
範例
// cliext_deque_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::deque<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
cliext::deque<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a c c
deque::generic_value (STL/CLR)
要與容器之泛型介面搭配使用的元素型別。
語法
typedef GValue generic_value;
備註
此類型描述 型 GValue 別的物件，該物件描述要與這個範本容器類別之泛型介面搭配使用的預存專案值。
範例
// cliext_deque_generic_value.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
cliext::deque<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a a c
deque::insert (STL/CLR)
在指定的位置加入專案。
語法
iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
System::Collections::Generic::IEnumerable<Value>^ right);
參數
計數
要插入的元素數目。
first
要插入的範圍開頭。
last
要插入的範圍結尾。
right
要插入的列舉。
val
要插入的專案值。
where
容器中要插入之前的位置。
備註
每個成員函式都會在受控制序列中的位置所指向 的 元素之前插入 ，這是其餘運算元所指定的序列。
第一個成員函式會插入值為 val 的專案，並傳回指定新插入專案的反覆運算器。 您可以使用它，在反覆運算器所指定的位置之前插入單一元素。
第二個成員函式會插入 value val 的 count 元素重複 。 您可以使用它插入零個或多個連續元素，這些元素都是相同值的所有複本。
如果 InIt 是整數類型，第三個成員函式的行為即與 insert(where, (size_type)first, (value_type)last) 相同。 否則，它會插入序列 [ first ， last 。 您可以使用它插入從另一個序列複製的零個或多個連續元素。
第四個成員函式會插入右邊 所 指定的序列。 您可以使用它來插入列舉值所描述的序列。
插入單一元素時，元素複本的數目會以插入點與序列更接近結尾之間的專案數目為線性。 （在序列的任一端插入一或多個專案時，不會發生任何專案複製。如果 InIt 是輸入反覆運算器，則第三個成員函式會有效地針對序列中的每個元素執行單一插入。 否則，插入 N 專案時，元素複本的數目會是線性的 N ，加上插入點與序列更接近結尾之間的專案數目。
範例
// cliext_deque_insert.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a single value using iterator
cliext::deque<wchar_t>::iterator it = c1.begin();
System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
*c1.insert(++it, L'x'));
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a repetition of values
cliext::deque<wchar_t> c2;
c2.insert(c2.begin(), 2, L'y');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert an iterator range
it = c1.end();
c2.insert(c2.end(), c1.begin(), --it);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert an enumeration
c2.insert(c2.begin(), // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b
deque::iterator (STL/CLR)
受控制序列之迭代器的類型。
語法
typedef T1 iterator;
備註
此類型描述未指定型 T1 別的物件，該物件可作為受控制序列的隨機存取反覆運算器。
範例
// cliext_deque_iterator.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
cliext::deque<wchar_t>::iterator it = c1.begin();
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
// alter first element and redisplay
it = c1.begin();
*it = L'x';
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
return (0);
}
a b c
x b c
deque::operator!= (STL/CLR)
Deque 不等於比較。
語法
template<typename Value>
bool operator!=(deque<Value>% left,
deque<Value>% right);
參數
left
要比較的左容器。
right
要比較的右容器。
備註
運算子函式會傳 !(left == right) 回 。 當您依元素比較兩個 deque 時，您可以使用它來測試 left 是否 不依右 順序排序 。
範例
// cliext_deque_operator_ne.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::deque<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] != [a b c] is {0}",
c1 != c1);
System::Console::WriteLine("[a b c] != [a b d] is {0}",
c1 != c2);
return (0);
}
a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True
deque::operator(STL/CLR)
存取指定位置的項目。
語法
reference operator[](size_type pos);
參數
pos
要存取的項目的位置。
備註
成員運算子會傳回位於位置 位置 的專案參考。您可以使用它來存取您知道其位置的專案。
範例
// cliext_deque_operator_sub.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" using subscripting
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1[i]);
System::Console::WriteLine();
// change an entry and redisplay
c1[1] = L'x';
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1[i]);
System::Console::WriteLine();
return (0);
}
a b c
a x c
deque::pop_back (STL/CLR)
移除最後一個專案。
語法
void pop_back();
備註
成員函式會移除受控制序列的最後一個專案，該元素必須是非空白的。 您可以使用它來縮短後面一個元素的 deque。
範例
// cliext_deque_pop_back.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// pop an element and redisplay
c1.pop_back();
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b
deque::pop_front (STL/CLR)
移除第一個專案。
語法
void pop_front();
備註
成員函式會移除受控制序列的第一個專案，該元素必須是非空白的。 您可以使用它來縮短前端一個專案的 deque。
範例
// cliext_deque_pop_front.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// pop an element and redisplay
c1.pop_front();
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
b c
deque::push_back (STL/CLR)
加入新的最後一個專案。
語法
void push_back(value_type val);
備註
成員函式會在受控制序列結尾插入具有值 val 的專案。 您可以使用它，將另一個專案附加至 deque。
範例
// cliext_deque_push_back.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
deque::push_front (STL/CLR)
加入新的第一個專案。
語法
void push_front(value_type val);
備註
成員函式會在受控制序列的開頭插入具有值的 val 元素。 您可以使用它在 deque 前面加上另一個專案。
範例
// cliext_deque_push_front.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_front(L'a');
c1.push_front(L'b');
c1.push_front(L'c');
// display contents " c b a"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
c b a
deque::rbegin (STL/CLR)
指定反向受控制序列的開頭。
語法
reverse_iterator rbegin();
備註
成員函式會傳回反向反覆運算器，指定受控制序列的最後一個專案，或剛好超出空序列的開頭。 因此，它會指定 beginning 反向序列的 。 您可以使用它來取得反覆運算器，指定 current 以反向順序顯示之受控制序列的開頭，但如果受控制序列的長度變更，其狀態可能會變更。
範例
// cliext_deque_rbegin.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items in reversed sequence
cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
System::Console::WriteLine("*rbegin() = {0}", *rit);
System::Console::WriteLine("*++rbegin() = {0}", *++rit);
// alter first two items and reinspect
*--rit = L'x';
*++rit = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*rbegin() = c
*++rbegin() = b
a y x
deque::reference (STL/CLR)
項目的參考類型。
語法
typedef value_type% reference;
備註
此類型描述專案的參考。
範例
// cliext_deque_reference.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
cliext::deque<wchar_t>::iterator it = c1.begin();
for (; it != c1.end(); ++it)
{ // get a reference to an element
cliext::deque<wchar_t>::reference ref = *it;
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
// modify contents " a b c"
for (it = c1.begin(); it != c1.end(); ++it)
{ // get a reference to an element
cliext::deque<wchar_t>::reference ref = *it;
ref += (wchar_t)(L'A' - L'a');
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
return (0);
}
a b c
A B C
deque::rend (STL/CLR)
指定反向受控制序列的結尾。
語法
reverse_iterator rend();
備註
成員函式會傳回反向反覆運算器，指向受控制序列的開頭以外。 因此，它會指定 end 反向序列的 。 您可以使用它來取得反覆運算器，指定 current 以反向順序顯示的受控制序列結尾，但如果受控制序列的長度變更，其狀態可能會變更。
範例
// cliext_deque_rend.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
cliext::deque<wchar_t>::reverse_iterator rit = c1.rend();
--rit;
System::Console::WriteLine("*-- --rend() = {0}", *--rit);
System::Console::WriteLine("*--rend() = {0}", *++rit);
// alter first two items and reinspect
*--rit = L'x';
*++rit = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*-- --rend() = b
*--rend() = a
y x c
deque::resize (STL/CLR)
變更專案數目。
語法
void resize(size_type new_size);
void resize(size_type new_size, value_type val);
參數
new_size
受控制序列的新大小。
val
填補專案的值。
備註
成員函式可確保 deque：：size （STL/CLR） () 因此會傳回 new_size 。 如果它必須讓受控制序列更長，則第一個成員函式會附加值為 value_type() 的專案，而第二個成員函式則會附加具有 value val 的元素。 為了縮短受控制序列，這兩個成員函式都會有效地清除最後一個元素 deque：：size （STL/CLR） () -new_size 時間。 您可以使用它，藉由修剪或填補目前的受控制序列，確保受控制序列的大小 new_size 。
範例
// cliext_deque_resize.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
// construct an empty container and pad with default values
cliext::deque<wchar_t> c1;
System::Console::WriteLine("size() = {0}", c1.size());
c1.resize(4);
for each (wchar_t elem in c1)
System::Console::Write("{0} ", (int)elem);
System::Console::WriteLine();
// resize to empty
c1.resize(0);
System::Console::WriteLine("size() = {0}", c1.size());
// resize and pad
c1.resize(5, L'x');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
size() = 0
0 0 0 0
size() = 0
x x x x x
deque::reverse_iterator (STL/CLR)
受控制序列的反向迭代器類型。
語法
typedef T3 reverse_iterator;
備註
此類型描述未指定類型 T3 的物件，其可用作受控制序列的反向迭代器。
範例
// cliext_deque_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" reversed
cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
for (; rit != c1.rend(); ++rit)
System::Console::Write("{0} ", *rit);
System::Console::WriteLine();
// alter first element and redisplay
rit = c1.rbegin();
*rit = L'x';
for (; rit != c1.rend(); ++rit)
System::Console::Write("{0} ", *rit);
System::Console::WriteLine();
return (0);
}
c b a
x b a
deque::size (STL/CLR)
計算元素的數目。
語法
size_type size();
備註
成員函式會傳回受控制序列的長度。 您可以使用它來判斷目前在受控制序列中的元素數目。 如果您關心的只是序列是否具有非零大小，請參閱 deque：：empty （STL/CLR）。 ()
範例
// cliext_deque_size.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0} starting with 3", c1.size());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0} after clearing", c1.size());
// add elements and clear again
c1.push_back(L'a');
c1.push_back(L'b');
System::Console::WriteLine("size() = {0} after adding 2", c1.size());
return (0);
}
a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2
deque::size_type (STL/CLR)
兩個專案之間帶正負號距離的類型。
語法
typedef int size_type;
備註
此類型描述非負數專案計數。
範例
// cliext_deque_size_type.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
cliext::deque<wchar_t>::size_type diff = c1.end() - c1.begin();
System::Console::WriteLine("end()-begin() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
deque::swap (STL/CLR)
交換兩個容器的內容。
語法
void swap(deque<Value>% right);
參數
right
要交換內容的容器。
備註
成員函式會交換和 右 之間的 *this 受控制序列。 它會在固定時間內執行此動作，而且不會擲回任何例外狀況。 您可以使用它作為交換兩個容器內容的快速方式。
範例
// cliext_deque_swap.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct another container with repetition of values
cliext::deque<wchar_t> c2(5, L'x');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// swap and redisplay
c1.swap(c2);
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
x x x x x
x x x x x
a b c
deque::to_array (STL/CLR)
將受控制序列複製到新的陣列。
語法
cli::array<Value>^ to_array();
備註
成員函式會傳回包含受控制序列的陣列。 您可以使用它，以陣列形式取得受控制序列的複本。
範例
// cliext_deque_to_array.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// copy the container and modify it
cli::array<wchar_t>^ a1 = c1.to_array();
c1.push_back(L'd');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// display the earlier array copy
for each (wchar_t elem in a1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c d
a b c
deque::value_type (STL/CLR)
元素的類型。
語法
typedef Value value_type;
備註
此類型與範本參數 Value 同義。
範例
// cliext_deque_value_type.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" using value_type
for (cliext::deque<wchar_t>::iterator it = c1.begin();
it != c1.end(); ++it)
{ // store element in value_type object
cliext::deque<wchar_t>::value_type val = *it;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c
operator< （deque）（STL/CLR）
Deque 小於比較。
語法
template<typename Value>
bool operator<(deque<Value>% left,
deque<Value>% right);
參數
left
要比較的左容器。
right
要比較的右容器。
備註
運算子函式會傳回 true，如果針對它也是 true 的最低 !(right[i] < left[i]) 位置 i ，則傳 left[i] < right[i] 回 true。 否則，它會傳回 left->size() < right->size() You 使用它來測試 當兩個 deque 是依元素比較元素時，是否在向右 排序 左 鍵。
範例
// cliext_deque_operator_lt.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::deque<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] < [a b c] is {0}",
c1 < c1);
System::Console::WriteLine("[a b c] < [a b d] is {0}",
c1 < c2);
return (0);
}
a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True
operator<= （deque）（STL/CLR）
Deque 小於或等於比較。
語法
template<typename Value>
bool operator<=(deque<Value>% left,
deque<Value>% right);
參數
left
要比較的左容器。
right
要比較的右容器。
備註
運算子函式會傳 !(right < left) 回 。 您可以使用它來測試當兩個 deque 是依元素比較元素時，左方是否 在右 方 排序。
範例
// cliext_deque_operator_le.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::deque<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] <= [a b c] is {0}",
c1 <= c1);
System::Console::WriteLine("[a b d] <= [a b c] is {0}",
c2 <= c1);
return (0);
}
a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False
operator= (deque) (STL/CLR)
取代受控制的序列。
語法
deque<Value>% operator=(deque<Value>% right);
參數
right
要複製的容器。
備註
成員運算子會將 許可權 複製到 物件，然後傳 *this 回 。 您可以使用它，將受控制序列取代為右側 受控制序列 的複本。
範例
// cliext_deque_operator_as.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::deque<wchar_t> c2;
c2 = c1;
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
operator== (deque) (STL/CLR)
Deque 相等比較。
語法
template<typename Value>
bool operator==(deque<Value>% left,
deque<Value>% right);
參數
left
要比較的左容器。
right
要比較的右容器。
備註
只有當由左右 控制 之序列的長度相同，而且針對每個位置 ileft[i] ==right[i] 、 時，運算子函式才會傳回 true。 當您依元素比較兩個 deque 時，您可以使用它來測試 left 是否 排序與 右邊 相同。
範例
// cliext_deque_operator_eq.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::deque<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] == [a b c] is {0}",
c1 == c1);
System::Console::WriteLine("[a b c] == [a b d] is {0}",
c1 == c2);
return (0);
}
a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False
operator> （deque）（STL/CLR）
Deque 大於比較。
語法
template<typename Value>
bool operator>(deque<Value>% left,
deque<Value>% right);
參數
left
要比較的左容器。
right
要比較的右容器。
備註
運算子函式會傳 right<left 回 。 您可以使用它來測試 當兩個 deque 是依元素比較元素時，是否在右 方 排序左 鍵。
範例
// cliext_deque_operator_gt.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::deque<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] > [a b c] is {0}",
c1 > c1);
System::Console::WriteLine("[a b d] > [a b c] is {0}",
c2 > c1);
return (0);
}
a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True
operator>= （deque）（STL/CLR）
Deque 大於或等於比較。
語法
template<typename Value>
bool operator>=(deque<Value>% left,
deque<Value>% right);
參數
left
要比較的左容器。
right
要比較的右容器。
備註
運算子函式會傳 !(left<right) 回 。 當您依元素比較兩個 deque 時，您可以使用它來測試左方是否 在右 方排序 。
範例
// cliext_deque_operator_ge.cpp
// compile with: /clr
#include <cliext/deque>
int main()
{
cliext::deque<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::deque<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] >= [a b c] is {0}",
c1 >= c1);
System::Console::WriteLine("[a b c] >= [a b d] is {0}",
c1 >= c2);
return (0);
}
a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False
意見反應
即將登場：在 2024 年，我們將逐步淘汰 GitHub 問題作為內容的意見反應機制，並將它取代為新的意見反應系統。 如需詳細資訊，請參閱：https://aka.ms/ContentUserFeedback。
提交並檢視相關的意見反應