`unordered_set` クラス

[アーティクル]
10/12/2023

このクラステンプレートは、const Key 型の要素の可変長シーケンスを制御するオブジェクトを表します。このシーケンスは、ハッシュ関数によって、"バケット" と呼ばれる一列に並んだサブシーケンスに分割され、弱い順序付けがなされます。各バケット内では、比較関数によって要素間の大小関係が決定されます。各要素には、並べ替えキーと値という、2 つの側面があります。このシーケンスは、すべてのバケットの長さがおおよそ等しければ、シーケンス内の要素数にかかわらず一定の演算回数 (定数時間) で、任意の要素を検索、挿入、削除できるような方法で表現されます。最悪のケースは、すべての要素が 1 つのバケットに集められたときです。演算の回数は、シーケンス内の要素数に比例して増えることになります (線形時間)。要素を挿入しても反復子の有効性は失われません。また、要素を削除した場合は、削除された要素を指す反復子だけが無効化されます。

構文

template <
   class Key,
   class Hash = std::hash<Key>,
   class Pred = std::equal_to<Key>,
   class Alloc = std::allocator<Key>>
class unordered_set;

パラメーター

Key
キーの型。

Hash
ハッシュ関数のオブジェクト型。

Pred
等価比較関数のオブジェクト型。

Alloc
アロケータークラス。

メンバー

Typedefs

名前	説明
`allocator_type`	ストレージを管理するためのアロケーターの型です。
`const_iterator`	被制御シーケンスの定数反復子の型です。
`const_local_iterator`	被制御シーケンスの定数バケット反復子の型です。
`const_pointer`	要素への定数ポインターの型です。
`const_reference`	要素への定数参照の型です。
`difference_type`	2 つの要素間の距離を表す、符号付きの型です。
`hasher`	ハッシュ関数の型です。
`iterator`	被制御シーケンスの反復子の型です。
`key_equal`	比較関数の型です。
`key_type`	順序付けキーの型です。
`local_iterator`	被制御シーケンスのバケット反復子の型です。
`pointer`	要素へのポインターの型です。
`reference`	要素への参照の型です。
`size_type`	2 つの要素間の距離を表す、符号なしの型です。
`value_type`	要素の型。

関数

名前	説明
`begin`	被制御シーケンスの先頭を指定します。
`bucket`	キー値のバケット番号を取得します。
`bucket_count`	バケット数を取得します。
`bucket_size`	バケットのサイズを取得します。
`cbegin`	被制御シーケンスの先頭を指定します。
`cend`	被制御シーケンスの末尾を指定します。
`clear`	すべての要素を削除します。
`contains`^C++20	`unordered_set` 内に指定されたキーを持つ要素があるかどうかを確認します。
`count`	指定したキーに一致する要素の数を検索します。
`emplace`	構築された要素を適切な場所に追加します。
`emplace_hint`	構築された要素を適切な場所にヒントと一緒に追加します。
`empty`	要素が存在しないかどうかをテストします。
`end`	被制御シーケンスの末尾を指定します。
`equal_range`	指定したキーに一致する範囲を検索します。
`erase`	指定した位置にある要素を削除します。
`find`	指定したキーに一致する要素を検索します。
`get_allocator`	格納されているアロケーターオブジェクトを取得します。
`hash_function`	格納されているハッシュ関数オブジェクトを取得します。
`insert`	要素を追加します。
`key_eq`	格納されている比較関数オブジェクトを取得します。
`load_factor`	バケットごとの平均要素数をカウントします。
`max_bucket_count`	最大バケット数を取得します。
`max_load_factor`	バケットあたりの最大要素数を取得または設定します。
`max_size`	被制御シーケンスの最大サイズを取得します。
`rehash`	ハッシュテーブルをリビルドします。
`size`	要素の数をカウントします。
`swap`	2 つのコンテナーのコンテンツを交換します。
`unordered_set`	コンテナーオブジェクトを構築します。

演算子

名前	説明
`unordered_set::operator=`	ハッシュテーブルをコピーします。

解説

このオブジェクトは、このオブジェクトが制御するシーケンスを、格納されている 2 つのオブジェクト (unordered_set::key_equal 型の比較関数オブジェクトと、unordered_set::hasher 型のハッシュ関数オブジェクト) を呼び出すことによって並べ替えます。格納されている 1 つ目のオブジェクトには、メンバー関数 unordered_set::key_eq() を呼び出すことによってアクセスします。格納されている 2 つ目のオブジェクトには、メンバー関数 unordered_set::hash_function() を呼び出すことによってアクセスします。具体的には、X 型のすべての値 Y と Key について、key_eq()(X, Y) が呼び出され、2 つの引数値の大小関係が等しい場合は true が返されます。hash_function()(keyval) の呼び出しからは、size_t 型の値の分布が生成されます。クラステンプレート unordered_multiset クラスと異なり、unordered_set 型のオブジェクトでは、被制御シーケンスの任意の 2 つの要素間で key_eq()(X, Y) が常に false になることが保証されます。キーの重複は許されません。

このオブジェクトには、さらに、適切とされるバケットあたりの最大平均要素数を指定する最大テーブル占有率が格納されます。要素を挿入することによって unordered_set::load_factor() が最大テーブル占有率を超えるような場合、コンテナーは、バケット数を増やし、必要に応じて、ハッシュテーブルをリビルドします。

被制御シーケンスにおける要素の実際の順序は、ハッシュ関数、比較関数、挿入の順序、最大テーブル占有率、現在のバケット数などによって異なります。通常、被制御シーケンス内の要素の順序を予測することはできません。ただし、被制御シーケンス内で同じ大小関係を持った一連の要素は必ず隣接して存在します。

被制御シーケンスに対するストレージの割り当ておよび解放は、格納されている unordered_set::allocator_type 型のアロケーターオブジェクトを介して行われます。このアロケーターオブジェクトは、allocator 型のオブジェクトと同じ外部インターフェイスを持っている必要があります。コンテナーオブジェクトを代入しても、格納されているアロケーターオブジェクトはコピーされません。

`unordered_set::allocator_type`

ストレージを管理するためのアロケーターの型です。

typedef Alloc allocator_type;

解説

この型は、テンプレートパラメーター Allocのシノニムです。

例

// std__unordered_set__unordered_set_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
    << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}

al == std::allocator() is true

`begin`

被制御シーケンスまたはバケットの先頭を指定します。

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

パラメーター

nbucket
バケット番号。

解説

最初の 2 つのメンバー関数は、シーケンスの最初の要素 (または空のシーケンスの末尾の次の位置) を示す前方反復子を返します。最後の 2 つのメンバー関数は、バケット nbucket の最初の要素 (または空のバケットの末尾の次の位置) を示す前方反復子を返します。

例

// unordered_set_begin.cpp
// compile using: cl.exe /EHsc /nologo /W4 /MTd
#include <unordered_set>
#include <iostream>

using namespace std;

typedef unordered_set<char> MySet;

int main()
{
    MySet c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents using range-based for
    for (auto it : c1) {
    cout << "[" << it << "] ";
    }

    cout << endl;

    // display contents using explicit for
    for (MySet::const_iterator it = c1.begin(); it != c1.end(); ++it) {
        cout << "[" << *it << "] ";
    }

    cout << std::endl;

    // display first two items
    MySet::iterator it2 = c1.begin();
    cout << "[" << *it2 << "] ";
    ++it2;
    cout << "[" << *it2 << "] ";
    cout << endl;

    // display bucket containing 'a'
    MySet::const_local_iterator lit = c1.begin(c1.bucket('a'));
    cout << "[" << *lit << "] ";

    return (0);
}

[a] [b] [c]
[a] [b] [c]
[a] [b]
[a]

`bucket`

キー値のバケット番号を取得します。

size_type bucket(const Key& keyval) const;

パラメーター

keyval
マップするキー値。

解説

このメンバー関数は、その時点でキー値 keyvalに対応しているバケット番号を返します。

例

// std__unordered_set__unordered_set_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
    << std::endl;

    return (0);
}

[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

`bucket_count`

バケット数を取得します。

size_type bucket_count() const;

解説

このメンバー関数は、現在のバケット数を返します。

例

// std__unordered_set__unordered_set_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

`bucket_size`

バケットのサイズを取得します。

size_type bucket_size(size_type nbucket) const;

パラメーター

nbucket
バケット番号。

解説

メンバー関数は、バケット番号 nbucketのサイズを返します。

例

// std__unordered_set__unordered_set_bucket_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
    << std::endl;

    return (0);
}

[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

`cbegin`

範囲内の最初の要素を示す const 反復子を返します。

const_iterator cbegin() const;

戻り値

範囲の最初の要素、または空の範囲の末尾の次の位置 (空の範囲の場合、const) を指し示す cbegin() == cend() 前方アクセス反復子。

解説

cbegin の戻り値で範囲内の要素を変更することはできません。

begin() メンバー関数の代わりにこのメンバー関数を使用して、戻り値が const_iterator になることを保証できます。通常は、次の例に示すように auto 型推論キーワードと共に使用します。例では、Container が const と begin() をサポートする任意の種類の変更可能な (非 cbegin()) コンテナーであると見なします。

auto i1 = Container.begin();
// i1 isContainer<T>::iterator
auto i2 = Container.cbegin();

// i2 isContainer<T>::const_iterator

`cend`

範囲内の最後の要素の次の位置を指す const 反復子を返します。

const_iterator cend() const;

戻り値

範囲の末尾の次の位置を指し示す const 前方アクセス反復子。

解説

cend は、反復子が範囲の末尾を超えたかどうかをテストするために使用されます。

end() メンバー関数の代わりにこのメンバー関数を使用して、戻り値が const_iterator になることを保証できます。通常は、次の例に示すように auto 型推論キーワードと共に使用します。例では、Container が const と end() をサポートする任意の種類の変更可能な (非 cend()) コンテナーであると見なします。

auto i1 = Container.end();
// i1 isContainer<T>::iterator
auto i2 = Container.cend();

// i2 isContainer<T>::const_iterator

cend によって返された値は逆参照しないでください。

`clear`

すべての要素を削除します。

void clear();

解説

メンバー関数は、unordered_set::erase( unordered_set::begin()、unordered_set::end()) を呼び出します。詳細については、「unordered_set::erase「unordered_set::beginおよび「unordered_set::end」を参照してください。

例

// std__unordered_set__unordered_set_clear.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false

`const_iterator`

被制御シーケンスの定数反復子の型です。

typedef T1 const_iterator;

解説

この型は、被制御シーケンスの定数前方反復子として使用できるオブジェクトを表します。ここでは、実装定義型 T1 のシノニムとして記述されています。

例

// std__unordered_set__unordered_set_const_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
    std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

`const_local_iterator`

被制御シーケンスの定数バケット反復子の型です。

typedef T5 const_local_iterator;

解説

この型は、バケットの定数前方反復子として使用できるオブジェクトを表します。ここでは、実装定義型 T5 のシノニムとして記述されています。

例

// std__unordered_set__unordered_set_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

`const_pointer`

要素への定数ポインターの型です。

typedef Alloc::const_pointer const_pointer;

解説

この型は、被制御シーケンスの要素への定数ポインターとして使用できるオブジェクトを表します。

例

// std__unordered_set__unordered_set_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
    {
        Myset::const_pointer p = &*it;
        std::cout << "[" << *p << "] ";
    }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

`const_reference`

要素への定数参照の型です。

typedef Alloc::const_reference const_reference;

解説

この型は、被制御シーケンスの要素への定数参照として使用できるオブジェクトを表します。

例

// std__unordered_set__unordered_set_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
    {
        Myset::const_reference ref = *it;
        std::cout << "[" << ref << "] ";
    }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

`contains`

unordered_set 内に、指定されたキーを持つ要素があるかどうかを確認します。

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

パラメーター

K
キーの型。

Key
探す要素のキー値。

戻り値

要素がコンテナー内で見つかった場合は true。それ以外の場合は false。

解説

contains() は C++20 の新機能です。これを使用するには、/std:c++20 以降のコンパイラオプションを指定します。

template<class K> bool contains(const K& key) const が透過的な場合にのみ、key_compare はオーバーロードの解決に使用されます。

例

// Requires /std:c++20 or /std:c++latest
#include <unordered_set>
#include <iostream>

int main()
{
    std::unordered_set<int> theUnorderedSet = { 1, 2 };

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theUnorderedSet.contains(2) << '\n';
    std::cout << theUnorderedSet.contains(3) << '\n';

    return 0;
}

true
false

`count`

指定したキーに一致する要素の数を検索します。

size_type count(const Key& keyval) const;

パラメーター

keyval
検索対象のキー値。

解説

このメンバー関数は、unordered_set::equal_range(keyval) で区切られた範囲内の要素数を返します。

例

// std__unordered_set__unordered_set_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "count('A') == " << c1.count('A') << std::endl;
    std::cout << "count('b') == " << c1.count('b') << std::endl;
    std::cout << "count('C') == " << c1.count('C') << std::endl;

    return (0);
}

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

`difference_type`

2 つの要素間の距離を表す、符号付きの型です。

typedef T3 difference_type;

解説

符号付き整数型は、被制御シーケンス内にある 2 つの要素のアドレスの違いを表すことのできるオブジェクトを記述します。ここでは、実装定義型 T3 のシノニムとして記述されています。

例

// std__unordered_set__unordered_set_difference_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // compute positive difference
    Myset::difference_type diff = 0;
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    std::cout << "end()-begin() == " << diff << std::endl;

    // compute negative difference
    diff = 0;
    for (Myset::const_iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    std::cout << "begin()-end() == " << diff << std::endl;

    return (0);
}

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

`emplace`

インプレースで構築された (コピーまたは移動操作が実行されない) 要素を挿入します。

template <class... Args>
pair<iterator, bool>
emplace(
Args&&... args);

パラメーター

args
値が同じ順序付けになる要素がマップにまだ含まれていない場合に、unordered_set に挿入される要素を構築するために転送される引数。

戻り値

pair。その bool コンポーネントは、挿入が行われた場合は true を返し、unordered_set に既に順序の値が等しい要素が含まれている場合は false を返します。そのイテレーターコンポーネントは、新しい要素が挿入されたか要素が既に配置されているアドレスを返します。

このメンバー関数によって返されたペア pr の反復子コンポーネントにアクセスするには pr.first を使用し、この反復子を逆参照するには *(pr.first) を使用します。このメンバー関数によって返されたペア bool の pr コンポーネントにアクセスするには、pr.second を使用します。

解説

この関数では、反復子や参照は無効になりません。

挿入時、例外がスローされたが、コンテナーのハッシュ関数ではエラーが発生しなかった場合、コンテナーは変更されません。ハッシュ関数で例外がスローされた場合、結果は未定義になります。

コード例については、「set::emplace」を参照してください。

`emplace_hint`

インプレースで構築された (コピーまたは移動操作が実行されない) 要素を、配置ヒントと一緒に挿入します。

template <class... Args>
iterator emplace_hint(
const_iteratorwhere,
Args&&... args);

パラメーター

args
unordered_set が、挿入される要素をまだ含んでいない場合、より一般的には、キーが同じ順序付けになる要素をまだ含んでいない場合に、unordered_set に挿入される要素を構築するために転送される引数。

where
正しい挿入ポイントの検索を開始する場所に関するヒント。

戻り値

新しく挿入される要素を指す反復子。

要素が既に存在するために挿入が失敗した場合は、既存の要素を指す反復子を返します。

解説

この関数では、反復子や参照は無効になりません。

コード例については、「set::emplace_hint」を参照してください。

`empty`

要素が存在しないかどうかをテストします。

bool empty() const;

解説

このメンバー関数は、被制御シーケンスが空の場合に true を返します。

例

// std__unordered_set__unordered_set_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true
[e] [d]
size == 2
empty() == false

`end`

被制御シーケンスの末尾を指定します。

iterator end();

const_iterator end() const;

local_iterator end(size_type nbucket);

const_local_iterator end(size_type nbucket) const;

パラメーター

nbucket
バケット番号。

解説

最初の 2 つのメンバー関数は、シーケンスの末尾の次を示す前方反復子を返します。最後の 2 つのメンバー関数は、バケット nbucketの末尾の次を示す前方反復子を返します。

例

// std__unordered_set__unordered_set_end.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect last two items "[a] [b] "
    Myset::iterator it2 = c1.end();
    --it2;
    std::cout << "[" << *it2 << "] ";
    --it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.end(c1.bucket('a'));
    --lit;
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a] [b]
[a]

`equal_range`

指定したキーに一致する範囲を検索します。

std::pair<iterator, iterator>
equal_range(const Key& keyval);

std::pair<const_iterator, const_iterator>
equal_range(const Key& keyval) const;

パラメーター

keyval
検索対象のキー値。

解説

このメンバー関数は、[X.first, X.second) が keyval と同じ順序付けの被制御シーケンスの要素だけを区切る反復子 Xのペアを返します。そのような要素が存在しない場合は、どちらの反復子も end()です。

例

// std__unordered_set__unordered_set_equal_range.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display results of failed search
    std::pair<Myset::iterator, Myset::iterator> pair1 =
    c1.equal_range('x');
    std::cout << "equal_range('x'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    // display results of successful search
    pair1 = c1.equal_range('b');
    std::cout << "equal_range('b'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]

`erase`

unordered_set 内の要素または要素の範囲を指定した位置から削除するか、または指定したキーと一致する要素を削除します。

iterator erase(const_iterator Where);

iterator erase(const_iterator First, const_iterator Last);

size_type erase(const key_type& Key);

パラメーター

Where
削除される要素の位置。

First
削除される最初の要素の位置。

Last
削除される最後の要素の次の位置。

Key
削除される要素のキー値。

戻り値

最初の 2 つのメンバー関数の場合は、削除された要素の後の最初の残存要素、または unordered_set の最後の要素 (このような要素が存在しない場合) を指定する双方向反復子。

3 番目のメンバー関数の場合は、unordered_set から削除された要素の数を返します。

解説

コード例については、「set::erase」をご覧ください。

`find`

指定したキーに一致する要素を検索します。

const_iterator find(const Key& keyval) const;

パラメーター

keyval
検索対象のキー値。

解説

このメンバー関数は、unordered_set::equal_range(keyval).first を返します。

例

// std__unordered_set__unordered_set_find.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // try to find and fail
    std::cout << "find('A') == "
    << std::boolalpha << (c1.find('A') != c1.end()) << std::endl;

    // try to find and succeed
    Myset::iterator it = c1.find('b');
    std::cout << "find('b') == "
    << std::boolalpha << (it != c1.end())
    << ": [" << *it << "] " << std::endl;

    return (0);
}

[c] [b] [a]
find('A') == false
find('b') == true: [b]

`get_allocator`

格納されているアロケーターオブジェクトを取得します。

Alloc get_allocator() const;

解説

このメンバー関数は、格納されているアロケーターオブジェクトを返します。

例

// std__unordered_set__unordered_set_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
    << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}

al == std::allocator() is true

`hash_function`

格納されているハッシュ関数オブジェクトを取得します。

Hash hash_function() const;

解説

このメンバー関数は、格納されているハッシュ関数オブジェクトを返します。

例

// std__unordered_set__unordered_set_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}

hfn('a') == 1630279
hfn('b') == 1647086

`hasher`

ハッシュ関数の型です。

typedef Hash hasher;

解説

この型は、テンプレートパラメーター Hashのシノニムです。

例

// std__unordered_set__unordered_set_hasher.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}

hfn('a') == 1630279
hfn('b') == 1647086

`insert`

unordered_set に要素または要素範囲を挿入します。

// (1) single element
pair<iterator, bool> insert(const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool> insert(ValTy&& Val);

// (3) single element with hint
iterator insert(const_iterator Where, const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(const_iterator Where, ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(InputIterator First, InputIterator Last);

// (6) initializer list
void insert(initializer_list<value_type> IList);

パラメーター

Val
キーが同じ順序付けになる要素が map にまだ含まれていない場合に、unordered_set に挿入される要素の値。

Where
正しい挿入ポイントの検索を開始する場所

ValTy
unordered_set が value_type の要素を構築するために使用できる引数の型を指定し、Val を引数として完全転送するテンプレートパラメーター。

First
コピーされる最初の要素の位置。

Last
コピーされる最後の要素の次の位置。

InputIterator
入力反復子の要件を満たすテンプレート関数の引数。これは、value_type オブジェクトの構築に使用できる型の要素を指し示します。

IList
要素のコピー元の initializer_list。

戻り値

単一要素のメンバー関数 (1) と (2) は、pair を返し、このペアの bool コンポーネントは、挿入が行われた場合は true になり、順序の値が同じキーを持つ要素が unordered_set に既に含まれている場合は false になります。戻り値であるペアの反復子コンポーネントは、bool コンポーネントが true の場合は新しく挿入される要素を指し、bool コンポーネントが false の場合は既存の要素を指します。

単一要素とヒントのメンバー関数 (3) と (4) は、unordered_set に挿入された新しい要素の位置を指す反復子を返します。ただし、同じキーを持つ要素が既に存在する場合、この反復子は既存の要素を指します。

解説

この関数では、反復子、ポインター、参照は無効になりません。

要素を 1 つだけ挿入するとき、例外がスローされたが、コンテナーのハッシュ関数ではエラーが発生しなかった場合、コンテナーの状態は変更されません。ハッシュ関数で例外がスローされた場合、結果は未定義になります。複数の要素を挿入するときに例外がスローされた場合、コンテナーの状態は未指定ですが、有効な状態になっています。

単一要素メンバー関数によって返される pair pr の反復子コンポーネントにアクセスするには、 pr.first; を使用して、返されたペア内の反復子を逆参照します。use*pr.first、要素を提供します。 bool コンポーネントにアクセスするには、pr.second を使用します。例については、この記事で後ほど説明するサンプルコードを参照してください。

コンテナーの value_type は、コンテナーに属する typedef であり、set の場合、unordered_set<V>::value_type は const V 型です。

範囲を指定したメンバー関数 (5) は、範囲 [First, Last) の反復子によってアドレス指定された各要素に対応する unordered_set に要素値のシーケンスを挿入します。したがって、Last は挿入されません。コンテナーのメンバー関数 end() は、コンテナー内にある最後の要素の直後の位置を参照します。たとえば、ステートメント s.insert(v.begin(), v.end()); は、v のすべての要素を s に挿入しようとします。範囲内で一意の値を持つ要素だけが挿入されますが、値が重複する要素は無視されます。拒否される要素を確認するには、1 つの要素が指定された insert を使用します。

初期化子リストのメンバー関数 (6) は、initializer_list を使用して unordered_set に要素をコピーします。

インプレースで構築された (つまり、コピーまたは移動操作が実行されない) 要素の挿入については、「set::emplace」および「set::emplace_hint」を参照してください。

コード例については、「set::insert」を参照してください。

`iterator`

unordered_set 内の要素を読み取ることができる、定数の前方反復子を提供する型。

typedef implementation-defined iterator;

例

反復子の宣言方法や使用方法の例については、begin の例をご覧ください。

`key_eq`

格納されている比較関数オブジェクトを取得します。

Pred key_eq() const;

解説

このメンバー関数は、格納されている比較関数オブジェクトを返します。

例

// std__unordered_set__unordered_set_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
    << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
    << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

`key_equal`

比較関数の型です。

typedef Pred key_equal;

解説

この型は、テンプレートパラメーター Predのシノニムです。

例

// std__unordered_set__unordered_set_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
    << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
    << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

`key_type`

順序付けキーの型です。

typedef Key key_type;

解説

この型は、テンプレートパラメーター Keyのシノニムです。

例

// std__unordered_set__unordered_set_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

`load_factor`

バケットごとの平均要素数をカウントします。

float load_factor() const;

解説

このメンバー関数は、バケットごとの平均要素数 (float)unordered_set::size() / (float)unordered_set::bucket_count() を返します。

例

// std__unordered_set__unordered_set_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

`local_iterator`

バケット反復子の型。

typedef T4 local_iterator;

解説

この型は、バケットの前方反復子として使用できるオブジェクトを表します。ここでは、実装定義型 T4 のシノニムとして記述されています。

例

// std__unordered_set__unordered_set_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

`max_bucket_count`

最大バケット数を取得します。

size_type max_bucket_count() const;

解説

このメンバー関数は、現在許可されているバケットの最大数を返します。

例

// std__unordered_set__unordered_set_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

`max_load_factor`

バケットあたりの最大要素数を取得または設定します。

float max_load_factor() const;

void max_load_factor(float factor);

パラメーター

factor
新しい最大テーブル占有率。

解説

1 つ目のメンバー関数は、格納されている最大テーブル占有率を返します。 2 つ目のメンバー関数は、格納されている最大テーブル占有率を factorに置き換えます。

例

// std__unordered_set__unordered_set_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
    << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
    << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

`max_size`

被制御シーケンスの最大サイズを取得します。

size_type max_size() const;

解説

このメンバー関数は、オブジェクトが制御できる最も長いシーケンスの長さを返します。

例

// std__unordered_set__unordered_set_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    std::cout << "max_size() == " << c1.max_size() << std::endl;

    return (0);
}

max_size() == 4294967295

`operator=`

ハッシュテーブルをコピーします。

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

パラメーター

right
unordered_set 内にコピーされる unordered_set。

解説

unordered_setは、 operator= 内の既存の要素をすべて削除した後、 right の内容を unordered_setにコピーまたは移動します。

例

// unordered_set_operator_as.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

int main( )
{
    using namespace std;
    unordered_set<int> v1, v2, v3;
    unordered_set<int>::iterator iter;

    v1.insert(10);

    cout << "v1 = " ;
    for (iter = v1.begin(); iter != v1.end(); iter++)
        cout << *iter << " ";
    cout << endl;

    v2 = v1;
    cout << "v2 = ";
    for (iter = v2.begin(); iter != v2.end(); iter++)
        cout << *iter << " ";
    cout << endl;

    // move v1 into v2
    v2.clear();
    v2 = move(v1);
    cout << "v2 = ";
    for (iter = v2.begin(); iter != v2.end(); iter++)
        cout << *iter << " ";
    cout << endl;
}

`pointer`

要素へのポインターの型です。

typedef Alloc::pointer pointer;

解説

この型は、被制御シーケンスの要素へのポインターとして機能するオブジェクトを表します。

例

// std__unordered_set__unordered_set_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
    {
        Myset::key_type key = *it;
        Myset::pointer p = &key;
        std::cout << "[" << *p << "] ";
    }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

`reference`

要素への参照の型です。

typedef Alloc::reference reference;

解説

この型は、被制御シーケンスの要素への参照として機能するオブジェクトを表します。

例

// std__unordered_set__unordered_set_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
    {
        Myset::key_type key = *it;
        Myset::reference ref = key;
        std::cout << "[" << ref << "] ";
    }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

`rehash`

ハッシュテーブルをリビルドします。

void rehash(size_type nbuckets);

パラメーター

nbuckets
要求されたバケット数。

解説

メンバー関数は、バケット数を nbuckets 以上に変更し、必要に応じて、ハッシュテーブルをリビルドします。

例

// std__unordered_set__unordered_set_rehash.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_load_factor() == 0.1

`size`

要素の数をカウントします。

size_type size() const;

解説

このメンバー関数は、被制御シーケンスの長さを返します。

例

// std__unordered_set__unordered_set_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

`size_type`

2 つの要素間の距離を表す、符号なしの型です。

typedef T2 size_type;

解説

符号なし整数型は、被制御シーケンスの長さを表すことができるオブジェクトを表します。ここでは、実装定義型 T2 のシノニムとして記述されています。

例

// std__unordered_set__unordered_set_size_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;
    Myset::size_type sz = c1.size();

    std::cout << "size == " << sz << std::endl;

    return (0);
}

size == 0

`swap`

2 つのコンテナーのコンテンツを交換します。

void swap(unordered_set& right);

パラメーター

right
交換先のコンテナー。

解説

このメンバー関数は、*this と right の間で被制御シーケンスを交換します。 unordered_set::get_allocator() == right.get_allocator() の場合は、この処理が一定の時間内に実行されます。例外がスローされるのは、格納されている Tr 型の traits オブジェクトをコピーした場合のみで、2 つの被制御シーケンス内の要素を指定する反復子、参照、ポインターは一切無効化されません。それ以外の場合、2 つの被制御シーケンス内の要素数に比例した回数、要素の割り当てとコンストラクター呼び出しが実行されます。

例

// std__unordered_set__unordered_set_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    Myset c2;

    c2.insert('d');
    c2.insert('e');
    c2.insert('f');

    c1.swap(c2);

    // display contents "[f] [e] [d] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    swap(c1, c2);

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[f] [e] [d]
[c] [b] [a]

`unordered_set`

コンテナーオブジェクトを構築します。

unordered_set(const unordered_set& Right);

explicit unordered_set(
    size_typebucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

unordered_set(unordered_set&& Right);

unordered_set(initializer_list<Type> IList);

unordered_set(initializer_list<Type> IList, size_typebucket_count);

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash);

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash,
    const Comp& Comp);

unordered_set(
    initializer_list<Type> IList,
    size_typebucket_count,
    const Hash& Hash,
    const Comp& Comp,
    const Allocator& Al);

template <class InputIterator>
unordered_set(
    InputIteratorfirst,
    InputIteratorlast,
    size_typebucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

パラメーター

InputIterator
反復子の型。

Al
格納するアロケーターオブジェクト。

Comp
格納する比較関数オブジェクト。

Hash
格納するハッシュ関数オブジェクト。

bucket_count
最小バケット数。

Right
コピーするコンテナー。

IList
コピーする要素を含む initializer_list。

解説

1 つ目のコンストラクターは、Right によって制御されるシーケンスのコピーを指定します。 2 つ目のコンストラクターは、空の被制御シーケンスのコピーを指定します。 3 つ目のコンストラクターは、Right を移動することによって、シーケンスのコピーを指定します。4 つ目から 8 つ目のコンストラクターは、initializer_list を使用して、コピーする要素を指定します。 9 つ目のコンストラクターは、要素値 [first, last) のシーケンスを挿入します。

さらに、格納された複数の値を初期化する処理が実行されます。この処理は、すべてのコンストラクターに共通です。コピーコンストラクターについては、値が Right から取得されます。それ以外:

最小バケット数は、引数 bucket_count が指定されていれば、この引数から取得されます。それ以外の場合は、実装定義の値 (N0) としてここに記述した既定値が使用されます。

ハッシュ関数オブジェクトは、引数 Hash が指定されていれば、この引数から取得されます。それ以外の場合は、Hash() になります。

比較関数オブジェクトは、引数 Comp が指定されていれば、この引数から取得されます。それ以外の場合は、Comp() になります。

アロケーターオブジェクトは、引数 Al が指定されていれば、この引数から取得されます。それ以外の場合は、Alloc() になります。

`value_type`

要素の型。

typedef Key value_type;

解説

この型は、被制御シーケンス内の要素を示します。

例

// std__unordered_set__unordered_set_value_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_set<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin(); it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

次の方法で共有

unordered_set クラス

構文

パラメーター

メンバー

Typedefs

関数

演算子

解説

unordered_set::allocator_type

解説

例

begin

パラメーター

解説

例

bucket

パラメーター

解説

例

bucket_count

解説

例

bucket_size

パラメーター

解説

例

cbegin

戻り値

解説

cend

戻り値

解説

clear

解説

例

const_iterator

解説

例

const_local_iterator

解説

例

const_pointer

解説

例

const_reference

解説

例

contains

パラメーター

戻り値

解説

例

count

パラメーター

解説

例

difference_type

解説

例

emplace

パラメーター

戻り値

解説

emplace_hint

パラメーター

戻り値

解説

empty

解説

例

end

パラメーター

解説

例

equal_range

パラメーター

解説

例

erase

`unordered_set` クラス

`unordered_set::allocator_type`

`begin`

`bucket`

`bucket_count`

`bucket_size`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_local_iterator`

`const_pointer`

`const_reference`

`contains`

`count`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`hash_function`

`hasher`

`insert`

`iterator`

`key_eq`

`key_equal`

`key_type`

`load_factor`

`local_iterator`

`max_bucket_count`

`max_load_factor`

`max_size`

`operator=`

`pointer`

`reference`

`rehash`

`size`

`size_type`

`swap`