list (STL/CLR)

樣板類別描述一個物件，該物件控制具有雙向存取權之元素的不同長度序列。 您可以使用容器 list 來管理一連串的元素，做為節點的雙向連結清單，每個專案都會儲存一個元素。

在下列描述中， GValue 除非後者是 ref 類型，否則會與 Value 相同，在此情況下為 Value^ 。

語法

template<typename Value>
    ref class list
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        Microsoft::VisualC::StlClr::IList<GValue>
    { ..... };

參數

值
受控制序列中項目的類型。

需求

標頭： < cliext/list>

命名空間： cliext

宣告

類型定義	描述
list::const_iterator (STL/CLR)	用於受控制序列的常數迭代器類型。
list::const_reference (STL/CLR)	項目的常數參考類型。
list::const_reverse_iterator (STL/CLR)	用於受控制序列的常數反向迭代器類型。
list::difference_type (STL/CLR)	兩個項目之間帶正負號距離的類型。
list::generic_container (STL/CLR)	容器之泛型介面的類型。
list::generic_iterator (STL/CLR)	容器之泛型介面的反覆運算器類型。
list::generic_reverse_iterator (STL/CLR)	容器之泛型介面的反向反覆運算器類型。
list::generic_value (STL/CLR)	容器之泛型介面的專案型別。
list::iterator (STL/CLR)	受控制序列之迭代器的類型。
list::reference (STL/CLR)	項目的參考類型。
list::reverse_iterator (STL/CLR)	受控制序列的反向迭代器類型。
list::size_type (STL/CLR)	兩個項目之間帶正負號距離的類型。
list::value_type (STL/CLR)	元素的類型。

成員函式	描述
list::assign (STL/CLR)	取代所有項目。
list::back (STL/CLR)	存取最後一個項目。
list::begin (STL/CLR)	指定受控制序列的開頭。
list::clear (STL/CLR)	移除所有項目。
list::empty (STL/CLR)	測試項目是否不存在。
list::end (STL/CLR)	指定受控制序列的結尾。
list::erase (STL/CLR)	移除位於指定位置的項目。
list::front (STL/CLR)	存取第一個項目。
list::insert (STL/CLR)	在指定的位置加入專案。
list::list (STL/CLR)	建構容器物件。
list::merge (STL/CLR)	合併兩個已排序的受控制序列。
list::pop_back (STL/CLR)	移除最後一個專案。
list::pop_front (STL/CLR)	移除第一個專案。
list::push_back (STL/CLR)	加入新的最後一個專案。
list::push_front (STL/CLR)	加入新的第一個專案。
list::rbegin (STL/CLR)	指定反向受控制序列的開頭。
list::remove (STL/CLR)	移除具有指定值的專案。
list::remove_if (STL/CLR)	移除通過指定測試的專案。
list::rend (STL/CLR)	指定反向受控制序列的結尾。
list::resize (STL/CLR)	變更專案數目。
list::reverse (STL/CLR)	反轉受控制序列。
list::size (STL/CLR)	計算元素的數目。
list::sort (STL/CLR)	排序受控制序列。
list::splice (STL/CLR)	重新拼接節點之間的連結。
list::swap (STL/CLR)	交換兩個容器的內容。
list::to_array (STL/CLR)	將受控制序列複製到新的陣列。
list::unique (STL/CLR)	移除通過指定測試的相鄰項目。

屬性	說明
list::back_item (STL/CLR)	存取最後一個項目。
list::front_item (STL/CLR)	存取第一個項目。

運算子	描述
list::operator= (STL/CLR)	取代受控制的序列。
operator!= (list) (STL/CLR)	判斷物件是否 list 不等於另一個 list 物件。
運算子 < （清單） （STL/CLR）	判斷物件是否 list 小於另一個 list 物件。
operator < = （list） （STL/CLR）	判斷物件是否 list 小於或等於另一個 list 物件。
operator== (list) (STL/CLR)	判斷物件是否 list 等於另一個 list 物件。
運算子 > （清單） （STL/CLR）	判斷物件是否 list 大於另一個 list 物件。
operator > = （list） （STL/CLR）	判斷物件是否 list 大於或等於另一個 list 物件。

介面

介面	描述
ICloneable	複製 物件。
IEnumerable	循序通過元素。
ICollection	維護專案群組。
IEnumerable<T>	透過具型別的元素進行排序。
ICollection<T>	維護具型別專案的群組。
IList < 值>	維護泛型容器。

備註

物件會為其控制項的序列配置和釋放儲存體，做為雙向連結清單中的個別節點。 它會藉由改變節點之間的連結來重新排列元素，絕不是將某個節點的內容複寫到另一個節點。 這表示您可以自由插入和移除元素，而不會干擾其餘元素。 因此，清單是範本類別 佇列的基礎容器（STL/CLR） 或範本類別 堆疊（STL/CLR） 的良好候選項目。

list物件支援雙向反覆運算器，這表示您可以在指定的受控制序列中指定元素的反覆運算器，逐步執行相鄰元素。 特殊前端節點會對應至 list：：end 所傳 回的反覆運算器（STL/CLR）。 () 如果存在，您可以遞減此反覆運算器，以到達受控制序列中的最後一個專案。 您可以遞增清單反覆運算器以到達前端節點，然後它會比較等於 end() 。 但是您無法取值 由 傳 end() 回的反覆運算器。

請注意，您無法直接參考清單專案，因為它的數值位置 -- 需要隨機存取反覆運算器。 因此，清單 無法 作為範本類別 的基礎容器priority_queue （STL/CLR） 使用。

清單反覆運算器會將控制碼儲存至其相關聯的清單節點，進而將控制碼儲存至其相關聯的容器。 您只能搭配其相關聯的容器物件使用反覆運算器。 只要清單相關聯的清單節點與某些清單相關聯，清單反覆運算器就會維持有效狀態。 此外，有效的反覆運算器是可取值的 -- 您可以使用它來存取或改變它指定的元素值 -- 只要它不等於 end() 。

清除或移除專案會呼叫其預存值的解構函式。 終結容器會清除所有元素。 因此，元素類型為 ref 類別的容器可確保容器沒有元素超過該容器。 不過請注意，控制碼的容器不會 終結其元素。

成員

list::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_list_assign.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // assign a repetition of values
    cliext::list<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
    cliext::list<wchar_t>::iterator it = c1.end();
    c2.assign(c1.begin(), --it);
    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

list::back (STL/CLR)

存取最後一個項目。

語法

reference back();

備註

成員函式會傳回受控制序列最後一個專案的參考，該元素必須是非空白的。 當您知道它存在時，您可以使用它來存取最後一個專案。

範例

// cliext_list_back.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::back_item (STL/CLR)

存取最後一個項目。

語法

property value_type back_item;

備註

屬性會存取受控制序列的最後一個專案，該元素必須是非空白的。 當您知道它存在時，您可以使用它來讀取或寫入最後一個專案。

範例

// cliext_list_back_item.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::begin (STL/CLR)

指定受控制序列的開頭。

語法

iterator begin();

備註

成員函式會傳回隨機存取反覆運算器，指定受控制序列的第一個專案，或剛好超出空序列結尾。 您可以使用它來取得指定 current 受控制序列開頭的反覆運算器，但如果受控制序列的長度變更，其狀態可能會變更。

範例

// cliext_list_begin.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::clear (STL/CLR)

移除所有項目。

語法

void clear();

備註

成員函式會有效呼叫 list：：erase （STL/CLR） ( list：：begin （STL/CLR） (), list：：end （STL/CLR）。 ()) 您可以使用它來確保受控制序列是空的。

範例

// cliext_list_clear.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::const_iterator (STL/CLR)

用於受控制序列的常數迭代器類型。

語法

typedef T2 const_iterator;

備註

此類型描述未指定類型的 T2 物件，該物件可作為受控制序列的常數隨機存取反覆運算器。

範例

// cliext_list_const_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::list<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

list::const_reference (STL/CLR)

項目的常數參考類型。

語法

typedef value_type% const_reference;

備註

此類型描述專案的常數參考。

範例

// cliext_list_const_reference.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::list<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

list::const_reverse_iterator (STL/CLR)

受控制序列的常數反向反覆運算器類型。

語法

typedef T4 const_reverse_iterator;

備註

此類型描述未指定型 T4 別的物件，該物件可作為受控制序列的常數反向反覆運算器。

範例

// cliext_list_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::list<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

list::difference_type (STL/CLR)

兩個專案之間帶正負號距離的類型。

語法

typedef int difference_type;

備註

此類型描述帶正負號的專案計數。

範例

// cliext_list_difference_type.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<wchar_t>::difference_type diff = 0;
    for (cliext::list<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::list<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

list::empty (STL/CLR)

測試項目是否不存在。

語法

bool empty();

備註

成員函式會對空的受控制序列傳回 true。 它相當於 list：：size （STL/CLR）。 () == 0 您可以使用它來測試清單是否為空白。

範例

// cliext_list_empty.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::end (STL/CLR)

指定受控制序列的結尾。

語法

iterator end();

備註

成員函式會傳回隨機存取反覆運算器，指向受控制序列結尾以外的點。 您可以使用它來取得指定受控制序列結尾的反覆運算器;如果受控制序列的長度變更，其狀態不會變更。

範例

// cliext_list_end.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::erase (STL/CLR)

移除位於指定位置的項目。

語法

iterator erase(iterator where);
iterator erase(iterator first, iterator last);

參數

first
要清除的範圍開頭。

last
要清除的範圍結尾。

where
要清除的專案。

備註

第一個成員函式會移除所指向 之受控制序列的 元素。 您可以使用它來移除單一元素。

第二個成員函式會移除 [first, last) 範圍中受控制序列中的元素。 您可以使用它來移除零個或多個連續元素。

這兩個成員函式都會傳回反覆運算器，指定移除任何專案以外的第一個元素，如果沒有這類專案，則 為 list：：end （STL/CLR）。 ()

清除專案時，元素複本數目在清除結尾與序列結尾之間的元素數目中是線性的。 （在序列的任一端清除一或多個元素時，不會發生任何元素複製。

範例

// cliext_list_erase.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::front (STL/CLR)

存取第一個項目。

語法

reference front();

備註

成員函式會傳回受控制序列第一個專案的參考，該元素必須是非空白的。 當您知道它存在時，您可以使用它來讀取或寫入第一個元素。

範例

// cliext_list_front.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::front_item (STL/CLR)

存取第一個項目。

語法

property value_type front_item;

備註

屬性會存取受控制序列的第一個專案，該元素必須是非空白的。 當您知道它存在時，您可以使用它來讀取或寫入第一個元素。

範例

// cliext_list_front_item.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::generic_container (STL/CLR)

容器之泛型介面的類型。

語法

typedef Microsoft::VisualC::StlClr::
    IList<generic_value>
    generic_container;

備註

此類型描述此範本容器類別的泛型介面。

範例

// cliext_list_generic_container.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::generic_iterator (STL/CLR)

用於容器之泛型介面的反覆運算器類型。

語法

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

備註

此類型描述可搭配此範本容器類別之泛型介面使用的泛型反覆運算器。

範例

// cliext_list_generic_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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::list<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::list<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

list::generic_reverse_iterator (STL/CLR)

用於容器之泛型介面的反向反覆運算器類型。

語法

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseBidirectionalIterator<generic_value> generic_reverse_iterator;

備註

此類型描述可搭配此範本容器類別之泛型介面使用的泛型反向反覆運算器。

範例

// cliext_list_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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::list<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::list<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

list::generic_value (STL/CLR)

要與容器之泛型介面搭配使用的元素型別。

語法

typedef GValue generic_value;

備註

此類型描述 型 GValue 別的物件，該物件描述要與這個範本容器類別之泛型介面搭配使用的預存專案值。

範例

// cliext_list_generic_value.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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::list<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::list<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

list::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_list_insert.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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::list<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();

    // insert a single value using index
    it = c2.begin();
    ++it, ++it, ++it;
    c2.insert(it, L'z');
    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

list::iterator (STL/CLR)

受控制序列之迭代器的類型。

語法

typedef T1 iterator;

備註

此類型描述未指定型 T1 別的物件，該物件可作為受控制序列的隨機存取反覆運算器。

範例

// cliext_list_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::list<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

list::list (STL/CLR)

建構容器物件。

語法

list();
list(list<Value>% right);
list(list<Value>^ right);
explicit list(size_type count);
list(size_type count, value_type val);
template<typename InIt>
    list(InIt first, InIt last);
list(System::Collections::Generic::IEnumerable<Value>^ right);

參數

計數
要插入的元素數目。

first
要插入的範圍開頭。

last
要插入的範圍結尾。

right
要插入的物件或範圍。

val
要插入的專案值。

備註

建構函式：

list();

初始化沒有元素的受控制序列。 您可以使用它來指定空的初始控制序列。

建構函式：

list(list<Value>% right);

使用序列 [， right.end() 來初始化受控制序列 。 right.begin() 您可以使用它來指定初始受控制序列，這是由清單物件 控制之序列的 複本。

建構函式：

list(list<Value>^ right);

使用序列 [， right->end() 來初始化受控制序列 。 right->begin() 您可以使用它來指定初始受控制序列，該序列是由清單物件所控制，其控制碼正確 。

建構函式：

explicit list(size_type count);

初始化受控制序列，其 計數 專案各具有值 value_type() 。 您可以使用它來將容器填入所有具有預設值的專案。

建構函式：

list(size_type count, value_type val);

使用具有 value val 的每個計數 元素，初始化受控制序列 。 您可以使用它來填滿容器，其中所有元素都有相同的值。

建構函式：

template<typename InIt>

list(InIt first, InIt last);

使用序列 [， last 來初始化受控制序列 。 first 您可以使用它讓受控制序列成為另一個序列的複本。

建構函式：

list(System::Collections::Generic::IEnumerable<Value>^ right);

使用列舉值 右邊 所指定的序列，初始化受控制序列。 您可以使用它讓受控制序列成為列舉值所描述之另一個序列的複本。

範例

// cliext_list_construct.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
// construct an empty container
    cliext::list<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct with a repetition of default values
    cliext::list<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::list<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::list<wchar_t>::iterator it = c3.end();
    cliext::list<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::list<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::list<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::list<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

list::merge (STL/CLR)

合併兩個已排序的受控制序列。

語法

void merge(list<Value>% right);
template<typename Pred2>
    void merge(list<Value>% right, Pred2 pred);

參數

Pred
專案組的比較子。

right
要合併的容器。

備註

第一個成員函式會從由 右 控制的序列中移除所有元素，並將其插入受控制序列中。 這兩個序列之前都必須由 operator< 排序 -- 元素在逐一執行任一序列時，不能減少值。 產生的序列也會依 operator< 排序。 您可以使用這個成員函式，將兩個值增加的序列合併成同時增加值的序列。

第二個成員函式的行為與第一個函式相同，不同之處在于 pred -- pred(X, Y) 序列對於序列中元素後面的 Y 任何元素 X 都必須為 false。 您可以使用它來合併由述詞函式或您指定的委派所排序的兩個序列。

這兩個函式都會執行穩定的合併 -- 在產生的受控制序列中，任何一個原始受控制序列中都沒有反轉任何一個元素。 此外，如果一對元素 X 和 Y 在產生的受控制序列中具有相等的順序 -- !(X < Y) && !(X < Y) -- 原始受控制序列的專案會出現在由右 控制 之序列的專案之前。

範例

// cliext_list_merge.cpp
// compile with: /clr
#include <cliext/list>

typedef cliext::list<wchar_t> Mylist;
int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'c');
    c1.push_back(L'e');

    // display initial contents " a c e"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    cliext::list<wchar_t> c2;
    c2.push_back(L'b');
    c2.push_back(L'd');
    c2.push_back(L'f');

    // display initial contents " b d f"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // merge and display
    cliext::list<wchar_t> c3(c1);
    c3.merge(c2);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c2.size() = {0}", c2.size());

    // sort descending, merge descending, and redisplay
    c1.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    c3.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    c3.merge(c1, cliext::greater<wchar_t>());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c1.size() = {0}", c1.size());
    return (0);
    }

a c e
b d f
a b c d e f
c2.size() = 0
e c a
f e d c b a
f e e d c c b a a
c1.size() = 0

list::operator= (STL/CLR)

取代受控制的序列。

語法

list<Value>% operator=(list<Value>% right);

參數

right
要複製的容器。

備註

成員運算子會將 許可權 複製到 物件，然後傳 *this 回 。 您可以使用它，將受控制序列取代為右側 受控制序列 的複本。

範例

// cliext_list_operator_as.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::pop_back (STL/CLR)

移除最後一個專案。

語法

void pop_back();

備註

成員函式會移除受控制序列的最後一個專案，該元素必須是非空白的。 您可以使用它來縮短清單後面一個元素。

範例

// cliext_list_pop_back.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::pop_front (STL/CLR)

移除第一個專案。

語法

void pop_front();

備註

成員函式會移除受控制序列的第一個專案，該元素必須是非空白的。 您可以使用它，將清單縮短為前端的一個專案。

範例

// cliext_list_pop_front.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::push_back (STL/CLR)

加入新的最後一個專案。

語法

void push_back(value_type val);

備註

成員函式會在受控制序列結尾插入具有值 val 的專案。 您可以使用它將另一個專案附加至清單。

範例

// cliext_list_push_back.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::push_front (STL/CLR)

加入新的第一個專案。

語法

void push_front(value_type val);

備註

成員函式會在受控制序列的開頭插入具有值的 val 元素。 您可以使用它，將另一個專案前面加上清單。

範例

// cliext_list_push_front.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::rbegin (STL/CLR)

指定反向受控制序列的開頭。

語法

reverse_iterator rbegin();

備註

成員函式會傳回反向反覆運算器，指定受控制序列的最後一個專案，或剛好超出空序列的開頭。 因此，它會指定 beginning 反向序列的 。 您可以使用它來取得反覆運算器，指定 current 以反向順序顯示之受控制序列的開頭，但如果受控制序列的長度變更，其狀態可能會變更。

範例

// cliext_list_rbegin.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::reference (STL/CLR)

項目的參考類型。

語法

typedef value_type% reference;

備註

此類型描述專案的參考。

範例

// cliext_list_reference.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::list<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::list<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

list::remove (STL/CLR)

移除具有指定值的專案。

語法

void remove(value_type val);

參數

val
要移除的專案值。

備註

成員函式會移除受控制序列 ((System::Object^)val)->Equals((System::Object^)x) 中為 true 的專案（如果有的話）。 您可以使用它來清除具有指定值的任意專案。

範例

// cliext_list_remove.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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();

    // fail to remove and redisplay
    c1.remove(L'A');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // remove and redisplay
    c1.remove(L'b');
    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

list::remove_if (STL/CLR)

移除通過指定測試的專案。

語法

template<typename Pred1>
    void remove_if(Pred1 pred);

參數

Pred
測試要移除的專案。

備註

成員函式會從受控制序列中移除，且每個元素 X 皆 pred(X) 為 true。 您可以使用它來移除滿足您指定為函式或委派條件的所有元素。

範例

// cliext_list_remove_if.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'b');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b b b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // fail to remove and redisplay
    c1.remove_if(cliext::binder2nd<cliext::equal_to<wchar_t> >(
        cliext::equal_to<wchar_t>(), L'd'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // remove and redisplay
    c1.remove_if(cliext::binder2nd<cliext::not_equal_to<wchar_t> >(
        cliext::not_equal_to<wchar_t>(), L'b'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b b b c
a b b b c
b b b

list::rend (STL/CLR)

指定反向受控制序列的結尾。

語法

reverse_iterator rend();

備註

成員函式會傳回反向反覆運算器，指向受控制序列的開頭以外。 因此，它會指定 end 反向序列的 。 您可以使用它來取得反覆運算器，指定 current 以反向順序顯示的受控制序列結尾，但如果受控制序列的長度變更，其狀態可能會變更。

範例

// cliext_list_rend.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::resize (STL/CLR)

變更專案數目。

語法

void resize(size_type new_size);
void resize(size_type new_size, value_type val);

參數

new_size
受控制序列的新大小。

val
填補專案的值。

備註

成員函式同時確保 list：：size （STL/CLR） () 因此會 傳回new_size 。 如果它必須讓受控制序列更長，則第一個成員函式會附加值為 value_type() 的專案，而第二個成員函式則會附加具有 value val 的元素。 為了縮短受控制序列，這兩個成員函式都會有效地清除最後一個元素 list：：size （STL/CLR） () -new_size 時間。 您可以使用它，藉由修剪或填補目前的受控制序列，確保受控制序列的大小 new_size 。

範例

// cliext_list_resize.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
// construct an empty container and pad with default values
    cliext::list<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

list::reverse (STL/CLR)

反轉受控制序列。

語法

void reverse();

備註

成員函式會反轉受控制序列中所有元素的順序。 您可以使用它來反映專案清單。

範例

// cliext_list_reverse.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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();

    // reverse and redisplay
    c1.reverse();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
c b a

list::reverse_iterator (STL/CLR)

受控制序列的反向迭代器類型。

語法

typedef T3 reverse_iterator;

備註

此類型描述未指定類型 T3 的物件，其可用作受控制序列的反向迭代器。

範例

// cliext_list_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::size (STL/CLR)

計算元素的數目。

語法

size_type size();

備註

成員函式會傳回受控制序列的長度。 您可以使用它來判斷目前在受控制序列中的元素數目。 如果您關心的只是序列是否具有非零大小，請參閱 list：：empty （STL/CLR）。 ()

範例

// cliext_list_size.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::size_type (STL/CLR)

兩個專案之間帶正負號距離的類型。

語法

typedef int size_type;

備註

此類型描述非負數專案計數。

範例

// cliext_list_size_type.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<wchar_t>::size_type diff = 0;
    for (cliext::list<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

list::sort (STL/CLR)

排序受控制序列。

語法

void sort();
template<typename Pred2>
    void sort(Pred2 pred);

參數

Pred
專案組的比較子。

備註

第一個成員函式會重新排列受控制序列中的元素，讓它們依 operator< 排序-- 元素不會隨著您逐一查看序列而減少值。 您可以使用這個成員函式，依遞增順序排序序列。

第二個成員函式的行為與第一個函式相同，不同之處在于 pred -- pred(X, Y) 順序是針對結果序列中後續 Y 元素的任何元素 X ，排序次序為 false。 您可以使用它，依照述詞函式或委派所指定的順序來排序序列。

這兩個函式都會執行穩定的排序 -- 原始受控制序列中沒有任何專案在產生的受控制序列中反轉。

範例

// cliext_list_sort.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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();

    // sort descending and redisplay
    c1.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // sort ascending and redisplay
    c1.sort();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
c b a
a b c

list::splice (STL/CLR)

將節點之間的 Restitch 連結。

語法

void splice(iterator where, list<Value>% right);
void splice(iterator where, list<Value>% right,
    iterator first);
void splice(iterator where, list<Value>% right,
    iterator first, iterator last);

參數

first
要接合的範圍開頭。

last
要接合的範圍結尾。

right
要從中接合的容器。

where
容器中要接合之前的位置。

備註

第一個成員函式會在所控制序列中指向 的 元素之前插入由 右 控制的順序。 它也會從 右側 移除所有元素。 （ %right 不得等於 this 。）您可以使用它將所有清單分割成另一個清單。

第二個成員函式會移除由右 控制 之序列中第一個 所指向 的專案，並將它插入至所指向 之受控制序列中的元素之前。 （如果 where== ++first==first||where 為 ，則不會發生任何變更。您可以使用它，將一個清單的單一元素分割成另一個清單。

第三個成員函式會插入由 [， ] 所 指定的子範圍，從受控制序列中由右 方控制之元素之前所指定的子範圍。 lastfirst 它也會從由右 控制的 序列中移除原始子範圍。 （如果 right == this 為 ，則範圍 [ first ， last ） 不得包含指向 where 的專案。 您可以使用它，將零個或多個元素的子序列從一個清單分割到另一個清單。

範例

// cliext_list_splice.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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();

    // splice to a new list
    cliext::list<wchar_t> c2;
    c2.splice(c2.begin(), c1);
    System::Console::WriteLine("c1.size() = {0}", c1.size());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // return one element
    c1.splice(c1.end(), c2, c2.begin());
    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 remaining elements
    c1.splice(c1.begin(), c2, c2.begin(), c2.end());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c2.size() = {0}", c2.size());
    return (0);
    }

a b c
c1.size() = 0
a b c
a
b c
b c a
c2.size() = 0

list::swap (STL/CLR)

交換兩個容器的內容。

語法

void swap(list<Value>% right);

參數

right
要交換內容的容器。

備註

成員函式會交換和 右 之間的 *this 受控制序列。 它會在固定時間內執行此動作，而且不會擲回任何例外狀況。 您可以使用它作為交換兩個容器內容的快速方式。

範例

// cliext_list_swap.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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

list::to_array (STL/CLR)

將受控制序列複製到新的陣列。

語法

cli::array<Value>^ to_array();

備註

成員函式會傳回包含受控制序列的陣列。 您可以使用它，以陣列形式取得受控制序列的複本。

範例

// cliext_list_to_array.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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

list::unique (STL/CLR)

移除通過指定測試的相鄰項目。

語法

void unique();
template<typename Pred2>
    void unique(Pred2 pred);

參數

Pred
專案組的比較子。

備註

第一個成員函式會從受控制序列中移除 （erases） 每一個比較與前一個專案相等的專案 -- 如果元素 X 在 元素 Y 之前， X == Y 則成員函式會移除 Y 。 您可以使用它來移除比較相等之相鄰元素之每個子序列的所有複本。 請注意，如果受控制序列已排序，例如藉由呼叫 list：：sort （STL/CLR）， () 成員函式只會留下具有唯一值的元素。 (也因此才名為終端方法)。

第二個成員函式的行為與第一個函式相同，不同之處在于它會移除元素後面的每個元素 YXpred(X, Y) 。 您可以使用它來移除符合您所指定述詞函式或委派之相鄰元素之每個子序列的所有複本。 請注意，如果受控制序列的排序方式，例如藉由呼叫 sort(pred) ，成員函式只會留下與任何其他元素沒有對等順序的專案。

範例

// cliext_list_unique.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display contents after unique
    cliext::list<wchar_t> c2(c1);
    c2.unique();
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display contents after unique(not_equal_to)
    c2 = c1;
    c2.unique(cliext::not_equal_to<wchar_t>());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a a b c
a b c
a a

list::value_type (STL/CLR)

元素的類型。

語法

typedef Value value_type;

備註

此類型與範本參數 Value 同義。

範例

// cliext_list_value_type.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::list<wchar_t>::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

operator!= (list) (STL/CLR)

清單不等於比較。

語法

template<typename Value>
    bool operator!=(list<Value>% left,
        list<Value>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式會傳 !(left == right) 回 。 您可以使用它來測試當兩個清單依元素比較元素時，左方是否 與右 順序相同 。

範例

// cliext_list_operator_ne.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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< （清單）（STL/CLR）

清單小於比較。

語法

template<typename Value>
    bool operator<(list<Value>% left,
        list<Value>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式會傳回 true，如果針對它也是 true 的最低 !(right[i] < left[i]) 位置 i ，則傳 left[i] < right[i] 回 true。 否則，它會傳回 left->size() < right->size() You use it 來測試當兩個清單依元素比較元素時， 是否在右邊 排序 左 方。

範例

// cliext_list_operator_lt.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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<= （清單）（STL/CLR）

列出小於或等於比較的清單。

語法

template<typename Value>
    bool operator<=(list<Value>% left,
        list<Value>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式會傳 !(right < left) 回 。 您可以使用它來測試當兩個清單依元素比較元素時，左方是否 在右 方 排序。

範例

// cliext_list_operator_le.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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== (list) (STL/CLR)

列出相等比較。

語法

template<typename Value>
    bool operator==(list<Value>% left,
        list<Value>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

只有當由左右 控制 之序列的長度相同，而且針對每個位置 ileft[i] ==right[i] 、 時，運算子函式才會傳回 true。 您可以使用它來測試當兩個清單依元素比較元素時，左邊 的排序是否 與 右邊 相同。

範例

// cliext_list_operator_eq.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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> （清單）（STL/CLR）

清單大於比較。

語法

template<typename Value>
    bool operator>(list<Value>% left,
        list<Value>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式會傳 right<left 回 。 您可以使用它來測試當兩個清單依元素比較元素時，左邊是否 在右 方排序 。

範例

// cliext_list_operator_gt.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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>= （清單）（STL/CLR）

列出大於或等於比較的清單。

語法

template<typename Value>
    bool operator>=(list<Value>% left,
        list<Value>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式會傳 !(left<right) 回 。 您可以使用它來測試當兩個清單依元素比較元素時，左方是否 在右 方 排序。

範例

// cliext_list_operator_ge.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<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::list<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