`set` （STL/CLR）

發行項
10/12/2023

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

在下列描述中， GValue 與相同 GKey，這反過來會與 Key 相同，除非後者是 ref 類型，在此情況下為 Key^。

語法

template<typename Key>
    ref class set
        :   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::ITree<Gkey, GValue>
    { ..... };

參數

Key
受控制序列中專案之索引鍵元件的型別。

需求

標頭：<cliext/set>

命名空間：cliext

宣告

類型定義	描述
`set::const_iterator`	用於受控制序列的常數迭代器類型。
`set::const_reference`	項目的常數參考類型。
`set::const_reverse_iterator`	用於受控制序列的常數反向迭代器類型。
`set::difference_type`	兩個元素之間的（可能帶正負號）距離的類型。
`set::generic_container`	容器之泛型介面的類型。
`set::generic_iterator`	容器之泛型介面的反覆運算器類型。
`set::generic_reverse_iterator`	容器之泛型介面的反向反覆運算器類型。
`set::generic_value`	容器之泛型介面的專案型別。
`set::iterator`	受控制序列之迭代器的類型。
`set::key_compare`	兩個索引鍵的排序委派。
`set::key_type`	排序索引鍵的類型。
`set::reference`	項目的參考類型。
`set::reverse_iterator`	受控制序列的反向迭代器類型。
`set::size_type`	兩個項目之間（非負數）距離的類型。
`set::value_compare`	兩個元素值的排序委派。
`set::value_type`	元素的類型。

成員函數	描述
`set::begin`	指定受控制序列的開頭。
`set::clear`	移除所有項目。
`set::count`	計算符合指定索引鍵的專案。
`set::empty`	測試項目是否不存在。
`set::end`	指定受控制序列的結尾。
`set::equal_range`	尋找符合指定之索引鍵的範圍。
`set::erase`	移除位於指定位置的項目。
`set::find`	尋找符合指定之索引鍵的元素。
`set::insert`	加入項目。
`set::key_comp`	複製兩個索引鍵的排序委派。
`set::lower_bound`	尋找符合指定索引鍵的範圍開頭。
`set::make_value`	建構值物件。
`set::rbegin`	指定反向受控制序列的開頭。
`set::rend`	指定反向受控制序列的結尾。
`set::set`	建構容器物件。
`set::size`	計算元素的數目。
`set::swap`	交換兩個容器的內容。
`set::to_array`	將受控制序列複製到新的陣列。
`set::upper_bound`	尋找符合指定索引鍵的範圍結尾。
`set::value_comp`	複製兩個元素值的排序委派。

Operator	描述
`set::operator=`	取代受控制的序列。
`operator!=` （set）	判斷物件是否 `set` 不等於另一個 `set` 物件。
`operator<` （set）	判斷物件是否 `set` 小於另一個 `set` 物件。
`operator<=` （set）	判斷物件是否 `set` 小於或等於另一個 `set` 物件。
`operator==` （set）	判斷物件是否 `set` 等於另一個 `set` 物件。
`operator>` （set）	判斷物件是否 `set` 大於另一個 `set` 物件。
`operator>=` （set）	判斷物件是否 `set` 大於或等於另一個 `set` 物件。

介面

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

備註

物件會為其控制為個別節點的序列配置和釋放記憶體。它會將元素插入到（幾乎）平衡的樹狀結構中，它會藉由改變節點之間的連結來維持排序，絕不是將某個節點的內容複製到另一個節點。這表示您可以自由插入和移除元素，而不會干擾其餘元素。

物件會藉由呼叫類型的 set::key_compare預存委派物件來排序它所控制的順序。您可以在建構集合時指定儲存的委派物件;如果您未指定委派物件，則預設值為比較 operator<(key_type, key_type)。您可以藉由呼叫成員函式 set::key_comp來存取這個預存物件。

這類委派對象必須對類型的 set::key_type索引鍵施加嚴格的弱式排序。這表示，針對任何兩個索引鍵 X 和 Y：

key_comp()(X, Y) 會在每個呼叫上傳回相同的布爾值結果。

如果 key_comp()(X, Y) 為 true，則 key_comp()(Y, X) 必須是 false。

如果 key_comp()(X, Y) 為 true，則 X 表示會在之前 Y排序。

如果 !key_comp()(X, Y) && !key_comp()(Y, X) 為 true，則 X 表示 Y 具有對等的排序。

對於受控制序列中之前Y的任何專案X，key_comp()(Y, X)為 false。（針對預設委派物件，索引鍵永遠不會減少值。）不同於樣板類別集，樣板類別set的物件不需要所有元素的索引鍵都是唯一的。（兩個或多個索引鍵可以有對等的排序。

每個元素都做為索引鍵和值。序列是以允許在對數時間中查閱、插入和移除任意元素的方式表示。也就是說，作業數目會與序列中元素數目的對數成正比。此外，插入元素不會使反覆運算器失效，而移除元素只會使指向已移除元素的反覆運算器失效。

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

您無法直接參考 set 元素的數值位置。這需要隨機存取反覆運算器。

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

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

成員

`set::begin`

指定受控制序列的開頭。

語法

iterator begin();

備註

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

範例

// cliext_set_begin.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

a b c
*begin() = a
*++begin() = b

`set::clear`

移除所有項目。

語法

void clear();

備註

成員函式實際上會呼叫 erase(begin(), end())。您可以使用它來確保受控制序列是空的。

範例

// cliext_set_clear.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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.insert(L'a');
    c1.insert(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

`set::const_iterator`

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

語法

typedef T2 const_iterator;

備註

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

範例

// cliext_set_const_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    Myset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::const_reference`

項目的常數參考類型。

語法

typedef value_type% const_reference;

備註

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

範例

// cliext_set_const_reference.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    Myset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myset::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::const_reverse_iterator`

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

語法

typedef T4 const_reverse_iterator;

備註

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

範例

// cliext_set_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" reversed
    Myset::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

`set::count`

尋找符合指定索引鍵的項目數目。

語法

size_type count(key_type key);

參數

key
要搜尋的索引鍵值。

備註

成員函式會傳回受控制序列中具有對等順序 key的項目數目。您可以使用它來判斷目前在受控制序列中符合指定索引鍵的項目數目。

範例

// cliext_set_count.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

a b c
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

`set::difference_type`

兩個項目之間帶正負號距離的類型。

語法

typedef int difference_type;

備註

型別描述可能的負元素計數。

範例

// cliext_set_difference_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::difference_type diff = 0;
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

// compute negative difference
    diff = 0;
    for (Myset::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

`set::empty`

測試項目是否不存在。

語法

bool empty();

備註

成員函式會對空的受控制序列傳回 true。相當於 size() == 0。您可以使用它來測試是否 set 為空白。

範例

// cliext_set_empty.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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

`set::end`

指定受控制序列的結尾。

語法

iterator end();

備註

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

範例

// cliext_set_end.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);
    return (0);
    }

a b c
*-- --end() = b
*--end() = c

`set::equal_range`

尋找符合指定之索引鍵的範圍。

語法

cliext::pair<iterator, iterator> equal_range(key_type key);

參數

key
要搜尋的索引鍵值。

備註

成員函式會傳回一對反覆運算器 cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key))。您可以使用它來判斷目前在受控制序列中符合指定索引鍵的項目範圍。

範例

// cliext_set_equal_range.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
typedef Myset::pair_iter_iter Pairii;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

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

// display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

// display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("{0} ", *pair1.first);
    System::Console::WriteLine();
    return (0);
    }

a b c
equal_range(L'x') empty = True
b

`set::erase`

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

語法

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
size_type erase(key_type key)

參數

first
要清除的範圍開頭。

key
要清除的索引鍵值。

last
要清除的範圍結尾。

where
要清除的專案。

備註

第一個成員函式會移除所 where指向之受控制序列的元素，並傳回反覆運算器，指定移除專案以外的第一個元素，如果沒有 end() 這類專案，則傳回反覆運算器。您可以使用它來移除單一元素。

第二個成員函式會移除範圍 [first， last] 中受控制序列的元素，並傳回反覆運算器，指定任何移除之元素以外的第一個元素，如果沒有 end() 這類專案，則傳回反覆運算器。您可以使用它來移除零個或多個連續元素。

第三個成員函式會移除受控制序列的任何專案，其索引鍵的排序 key與相等，並傳回已移除之元素數目的計數。您可以使用它來移除並計算符合指定索引鍵的所有元素。

每個元素清除需要時間與受控制序列中元素數目的對數成正比。

範例

// cliext_set_erase.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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.insert(L'd');
    c1.insert(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// erase all but end
    Myset::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

`set::find`

尋找符合指定之索引鍵的元素。

語法

iterator find(key_type key);

參數

key
要搜尋的索引鍵值。

備註

如果受控制序列中至少有一個專案具有對等的順序 key，則成員函式會傳回反覆運算器，指定其中一個專案，否則會傳 end()回。您可以使用它來尋找目前在受控制序列中符合指定索引鍵的專案。

範例

// cliext_set_find.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());
    System::Console::WriteLine("find {0} = {1}",
        L'b', *c1.find(L'b'));
    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

a b c
find A = False
find b = b
find C = False

`set::generic_container`

容器之泛型介面的類型。

語法

typedef Microsoft::VisualC::StlClr::
    ITree<GKey, GValue>
    generic_container;

備註

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

範例

// cliext_set_generic_container.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::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(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify original and display generic
    c1.insert(L'e');
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

`set::generic_iterator`

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

語法

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

備註

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

範例

// cliext_set_generic_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// get an element and display it
    Myset::generic_iterator gcit = gc1->begin();
    Myset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`set::generic_reverse_iterator`

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

語法

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

備註

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

範例

// cliext_set_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// get an element and display it
    Myset::generic_reverse_iterator gcit = gc1->rbegin();
    Myset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
c

`set::generic_value`

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

語法

typedef GValue generic_value;

備註

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

範例

// cliext_set_generic_value.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// get an element and display it
    Myset::generic_iterator gcit = gc1->begin();
    Myset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

`set::insert`

加入項目。

語法

cliext::pair<iterator, bool> insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

參數

first
要插入的範圍開頭。

last
要插入的範圍結尾。

right
要插入的列舉。

val
要插入的索引鍵值。

where
容器中要插入的位置（僅限提示）。

備註

每個成員函式都會插入其餘操作數所指定的序列。

第一個成員函式會嘗試插入具有值 val的專案，並傳回一組值 X。如果 X.second 為 true， X.first 則指定新插入的專案;否則 X.first 會指定具有相等順序的專案，而且不會插入任何新專案。您可以使用它來插入單一元素。

第二個成員函式會使用 where 作為提示來插入具有值val的專案，並傳回指定新插入元素的反覆運算器。您可以使用它來插入可能位於您知道之專案旁邊的單一元素。

第三個成員函式會插入序列 [first， last。您可以使用它插入從另一個序列複製的零個或多個專案。

第四個成員函式會插入所 right指定的序列。您可以使用它來插入列舉值所描述的序列。

每個元素插入需要時間與受控制序列中元素數目的對數成正比。不過，在指定插入點旁邊的專案提示時，插入可能會以分攤的常數時間發生。

範例

// cliext_set_insert.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
typedef Myset::pair_iter_bool Pairib;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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, unique and duplicate
    Pairib pair1 = c1.insert(L'x');
    System::Console::WriteLine("insert(L'x') = [{0} {1}]",
        *pair1.first, pair1.second);

    pair1 = c1.insert(L'b');
    System::Console::WriteLine("insert(L'b') = [{0} {1}]",
        *pair1.first, pair1.second);

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert a single value with hint
    System::Console::WriteLine("insert(begin(), L'y') = {0}",
        *c1.insert(c1.begin(), L'y'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an iterator range
    Myset c2;
    Myset::iterator it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an enumeration
    Myset c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(L'x') = [x True]
insert(L'b') = [b False]
a b c x
insert(begin(), L'y') = y
a b c x y
a b c x
a b c x y

`set::iterator`

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

語法

typedef T1 iterator;

備註

此類型描述非指定型 T1 別的物件，該對象可作為受控制序列的雙向反覆運算器。

範例

// cliext_set_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    Myset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::key_comp`

複製兩個索引鍵的排序委派。

語法

key_compare^key_comp();

備註

成員函式會傳回用來排序受控制序列的排序委派。您可以使用它來比較兩個索引鍵。

範例

// cliext_set_key_comp.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

// test a different ordering rule
    Myset c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`set::key_compare`

兩個索引鍵的排序委派。

語法

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

備註

此類型與決定其索引鍵自變數順序的委派同義。

範例

// cliext_set_key_compare.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

// test a different ordering rule
    Myset c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`set::key_type`

排序索引鍵的類型。

語法

typedef Key key_type;

備註

此類型是範本參數 Key的同義字。

範例

// cliext_set_key_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" using key_type
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myset::key_type val = *it;

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

a b c

`set::lower_bound`

尋找符合指定索引鍵的範圍開頭。

語法

iterator lower_bound(key_type key);

參數

key
要搜尋的索引鍵值。

備註

成員函式會決定受控制序列中具有對等順序key的第一個專案X。如果不存在這類專案，則會傳 end()回，否則會傳回指定 X的反覆運算器。您可以使用它來尋找目前在受控制序列中符合指定索引鍵之元素序列的開頭。

範例

// cliext_set_lower_bound.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    System::Console::WriteLine("*lower_bound(L'a') = {0}",
        *c1.lower_bound(L'a'));
    System::Console::WriteLine("*lower_bound(L'b') = {0}",
        *c1.lower_bound(L'b'));
    return (0);
    }

a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b

`set::make_value`

建構值物件。

語法

static value_type make_value(key_type key);

參數

key
要使用的索引鍵值。

備註

成員函式會傳 value_type 回索引鍵為 key的物件。您可以使用它來撰寫適合與數個其他成員函式搭配使用的物件。

範例

// cliext_set_make_value.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(Myset::make_value(L'a'));
    c1.insert(Myset::make_value(L'b'));
    c1.insert(Myset::make_value(L'c'));

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

a b c

`set::operator=`

取代受控制的序列。

語法

set<Key>% operator=(set<Key>% right);

參數

right
要複製的容器。

備註

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

範例

// cliext_set_operator_as.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

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

// assign to a new container
    Myset c2;
    c2 = c1;
// display contents " a b c"
    for each (Myset::value_type elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

`set::rbegin`

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

語法

reverse_iterator rbegin();

備註

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

範例

// cliext_set_rbegin.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b

`set::reference`

項目的參考類型。

語法

typedef value_type% reference;

備註

此類型描述項目的參考。

範例

// cliext_set_reference.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    Myset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myset::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::rend`

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

語法

reverse_iterator rend();

備註

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

範例

// cliext_set_rend.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a

`set::reverse_iterator`

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

語法

typedef T3 reverse_iterator;

備註

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

範例

// cliext_set_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" reversed
    Myset::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a

`set::set`

建構容器物件。

語法

set();
explicit set(key_compare^ pred);
set(set<Key>% right);
set(set<Key>^ right);
template<typename InIter>
    setset(InIter first, InIter last);
template<typename InIter>
    set(InIter first, InIter last,
        key_compare^ pred);
set(System::Collections::Generic::IEnumerable<GValue>^ right);
set(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);

參數

first
要插入的範圍開頭。

last
要插入的範圍結尾。

pred
排序受控制序列的述詞。

right
要插入的物件或範圍。

備註

建構函式：

set();

使用預設順序述 key_compare()詞，初始化沒有元素的受控制序列。您可以使用它來指定空的初始控制序列，並使用預設順序述詞。

建構函式：

explicit set(key_compare^ pred);

使用排序述詞 pred，初始化沒有元素的受控制序列。您可以使用它來指定空的初始控制序列，並指定順序述詞。

建構函式：

set(set<Key>% right);

使用序列 [right.begin()， right.end()使用預設順序述詞，初始化受控制序列。您可以使用它來指定一個初始受控制序列，該序列是由物件 right所控制set，且具有預設排序述詞。

建構函式：

set(set<Key>^ right);

使用序列 [right->begin()， right->end()使用預設順序述詞，初始化受控制序列。您可以使用它來指定一個初始受控制序列，該序列是由物件 right所控制set，且具有預設排序述詞。

建構函式：

template<typename InIter> set(InIter first, InIter last);

使用序列 [first， last使用預設順序述詞，初始化受控制序列。您可以使用它讓受控制序列成為另一個序列的複本，並使用預設的排序述詞。

建構函式：

template<typename InIter> set(InIter first, InIter last, key_compare^ pred);

使用序列 [first， last使用排序述詞 pred，初始化受控制序列。您可以使用它讓受控制序列成為另一個序列的複本，並搭配指定的排序述詞。

建構函式：

set(System::Collections::Generic::IEnumerable<Key>^ right);

使用列舉值 right所指定的序列，使用預設順序述詞，初始化受控制序列。您可以使用它，讓受控制序列成為列舉值所描述之另一個序列的複本，並具有預設順序述詞。

建構函式：

set(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

使用列舉值 right所指定的序列，使用排序述 pred詞，初始化受控制序列。您可以使用它，讓受控制序列成為列舉值所描述之另一個序列的複本，並具有指定的排序述詞。

範例

// cliext_set_construct.cpp
// compile with: /clr
#include <cliext/set>

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

    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an ordering rule
    Myset c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an iterator range
    Myset c3(c1.begin(), c1.end());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an iterator range and an ordering rule
    Myset c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an enumeration
    Myset 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 with an enumeration and an ordering rule
    Myset c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c6)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct from a generic container
    Myset c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying another container
    Myset c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
a b c
size() = 0
c b a
a b c
c b a
a b c
c b a
c b a
a b c

`set::size`

計算元素的數目。

語法

size_type size();

備註

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

範例

// cliext_set_size.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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.insert(L'a');
    c1.insert(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

`set::size_type`

兩個項目之間帶正負號距離的類型。

語法

typedef int size_type;

備註

此類型描述非負數項目計數。

範例

// cliext_set_size_type.cpp
// compile with: /clr
#include <cliext/set>

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

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

`set::swap`

交換兩個容器的內容。

語法

void swap(set<Key>% right);

參數

right
要交換內容的容器。

備註

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

範例

// cliext_set_swap.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset c2;
    c2.insert(L'd');
    c2.insert(L'e');
    c2.insert(L'f');
    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
d e f
d e f
a b c

`set::to_array`

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

語法

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

備註

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

範例

// cliext_set_to_array.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.insert(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

`set::upper_bound`

尋找符合指定索引鍵的範圍結尾。

語法

iterator upper_bound(key_type key);

參數

key
要搜尋的索引鍵值。

備註

成員函式會決定受控制序列中最後一 X 個專案，該元素的排序 key與相等。如果不存在這類專案，或者如果 X 為受控制序列中的最後一個專案，則會傳 end()回 ;否則會傳回指定以外的 X第一個專案的反覆運算器。您可以使用它來找出目前在受控制序列中符合指定索引鍵之元素序列的結尾。

範例

// cliext_set_upper_bound.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    System::Console::WriteLine("*upper_bound(L'a') = {0}",
        *c1.upper_bound(L'a'));
    System::Console::WriteLine("*upper_bound(L'b') = {0}",
        *c1.upper_bound(L'b'));
    return (0);
    }

a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c

`set::value_comp`

複製兩個元素值的排序委派。

語法

value_compare^ value_comp();

備註

成員函式會傳回用來排序受控制序列的排序委派。您可以使用它來比較兩個元素值。

範例

// cliext_set_value_comp.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`set::value_compare`

兩個元素值的排序委派。

語法

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

備註

此類型與決定其值自變數順序的委派同義。

範例

// cliext_set_value_compare.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

`set::value_type`

元素的類型。

語法

typedef generic_value value_type;

備註

此類型是 generic_value的同義字。

範例

// cliext_set_value_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" using value_type
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myset::value_type val = *it;

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

a b c

`operator!=` （set）

清單不等於比較。

語法

template<typename Key>
    bool operator!=(set<Key>% left,
        set<Key>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式會傳 !(left == right)回。您可以使用它來測試是否 left 與依元素比較這兩個集合時的順序不同 right 。

範例

// cliext_set_operator_ne.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(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<` （set）

清單小於比較。

語法

template<typename Key>
    bool operator<(set<Key>% left,
        set<Key>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

如果針對也是 true 的最低位置i!(right[i] < left[i])，運算子函式會傳回 trueleft[i] < right[i]。否則會傳回 left->size() < right->size()。您可以使用它來測試兩個集合是否 left 依元素比較元素之前 right 排序。

範例

// cliext_set_operator_lt.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(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<=` （set）

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

語法

template<typename Key>
    bool operator<=(set<Key>% left,
        set<Key>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

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

範例

// cliext_set_operator_le.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(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==` （set）

列出相等比較。

語法

template<typename Key>
    bool operator==(set<Key>% left,
        set<Key>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式只有在所left控制的序列具有相同的長度，而且right針對每個位置 ileft[i] == right[i]、，傳回 true。您可以使用它來測試是否 left 依元素比較兩個集合時排序的相同 right 。

範例

// cliext_set_operator_eq.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(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>` （set）

清單大於比較。

語法

template<typename Key>
    bool operator>(set<Key>% left,
        set<Key>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式會傳 right < left回。您可以使用它來測試當兩個集合依元素比較元素時，是否 left 在之後 right 排序。

範例

// cliext_set_operator_gt.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(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>=` （set）

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

語法

template<typename Key>
    bool operator>=(set<Key>% left,
        set<Key>% right);

參數

left
要比較的左容器。

right
要比較的右容器。

備註

運算子函式會傳 !(left < right)回。您可以使用它來測試兩 left 個集合是否依元素比較元素之前 right 未排序。

範例

// cliext_set_operator_ge.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(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
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(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

共用方式為

set （STL/CLR）

語法

參數

需求

宣告

介面

備註

成員

set::begin

語法

備註

範例

set::clear

語法

備註

範例

set::const_iterator

語法

備註

範例

set::const_reference

語法

備註

範例

set::const_reverse_iterator

語法

備註

範例

set::count

語法

參數

備註

範例

set::difference_type

語法

備註

範例

set::empty

語法

備註

範例

set::end

語法

備註

範例

set::equal_range

語法

參數

備註

範例

set::erase

語法

參數

備註

範例

set::find

語法

參數

備註

範例

set::generic_container

語法

備註

範例

set::generic_iterator

語法

備註

範例

set::generic_reverse_iterator

語法

備註

範例

set::generic_value

語法

備註

範例

set::insert

語法

參數

`set` （STL/CLR）

`set::begin`

`set::clear`

`set::const_iterator`

`set::const_reference`

`set::const_reverse_iterator`

`set::count`

`set::difference_type`

`set::empty`

`set::end`

`set::equal_range`

`set::erase`

`set::find`

`set::generic_container`

`set::generic_iterator`

`set::generic_reverse_iterator`

`set::generic_value`

`set::insert`

`set::iterator`

`set::key_comp`

`set::key_compare`

`set::key_type`

`set::lower_bound`

`set::make_value`

`set::operator=`

`set::rbegin`

`set::reference`

`set::rend`

`set::reverse_iterator`

`set::set`

`set::size`

`set::size_type`

`set::swap`

`set::to_array`