`unordered_set` Sınıf

Makale
10/12/2023

Sınıf şablonu, türünde const Keyöğelerin değişen uzunlukta bir dizisini denetleen bir nesneyi açıklar. Dizi çağrılan demetlerin sıralı bir dizi kümesini bölümleyen bir karma işlev tarafından zayıf bir şekilde sıralanır. Her demet içinde bir karşılaştırma işlevi, herhangi bir öğe çiftinin eşdeğer sıralamaya sahip olup olmadığını belirler. Her bir öğe hem bir sıralama anahtarı hem de bir değer depolar. Dizi, en azından tüm demetleri kabaca eşit uzunlukta olduğunda, dizideki (sabit zaman) öğe sayısından bağımsız olabilen işlem sayısına sahip rastgele bir öğenin aranması, eklenmesi ve kaldırılmasına izin verecek şekilde temsil edilir. En kötü durumda, tüm öğeler tek bir demet içinde olduğunda işlem sayısı dizideki (doğrusal zaman) öğelerin sayısıyla orantılıdır. Öğe eklemek yineleyicileri geçersiz kılmaz ve bir öğeyi kaldırmak yalnızca kaldırılan öğeyi işaret eden yineleyicileri geçersiz kılır.

Sözdizimi

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

Parametreler

Key
Anahtar türü.

Hash
Karma işlev nesne türü.

Pred
Eşitlik karşılaştırma işlevi nesne türü.

Alloc
Ayırıcı sınıf.

Üyeler

Tür tanımları

Veri Akışı Adı	Açıklama
`allocator_type`	Depolamayı yönetmek için bir ayırıcı türü.
`const_iterator`	Denetlenen dizi için bir sabit yineleyici türü.
`const_local_iterator`	Denetlenen dizi için bir sabit demet yineleyici türü.
`const_pointer`	Bir öğe için sabit bir işaretçi türü.
`const_reference`	Bir öğe için sabit bir başvuru türü.
`difference_type`	İki öğe arasındaki işaretli mesafenin türü.
`hasher`	Karma işlevin türü.
`iterator`	Denetlenen dizi için bir yineleyici türü.
`key_equal`	Karşılaştırma işlevinin türü.
`key_type`	Bir sıralama anahtarının türü.
`local_iterator`	Denetlenen dizi için bir demet yineleyici türü.
`pointer`	Bir öğe için bir işaretçi türü.
`reference`	Bir öğe için bir başvuru türü.
`size_type`	İki öğe arasındaki işaretsiz bir mesafenin türü.
`value_type`	Öğenin türü.

İşlevler

Veri Akışı Adı	Açıklama
`begin`	Denetlenen dizinin başlangıcını belirtir.
`bucket`	Bir anahtar değeri için demet numarasını alır.
`bucket_count`	Demet sayısını alır.
`bucket_size`	Demet boyutunu alır.
`cbegin`	Denetlenen dizinin başlangıcını belirtir.
`cend`	Denetlenen dizinin bitişini belirtir.
`clear`	Tüm öğeleri kaldırır.
`contains`^C++20	içinde `unordered_set`belirtilen anahtara sahip bir öğe olup olmadığını denetleyin.
`count`	Belirtilen bir anahtar ile eşleşen öğe sayısını bulur.
`emplace`	Yerinde oluşturulmuş bir öğe ekler.
`emplace_hint`	Göstergeyle birlikte, yerinde oluşturulmuş bir öğe ekler.
`empty`	Bir öğe olup olmadığını sınar.
`end`	Denetlenen dizinin bitişini belirtir.
`equal_range`	Belirtilen bir anahtarla eşleşen aralığı bulur.
`erase`	Belirtilen konumlardaki öğeleri kaldırır.
`find`	Belirtilen bir anahtarla eşleşen bir öğeyi bulur.
`get_allocator`	Depolanan ayırıcı nesnesini alır.
`hash_function`	Depolanan karma işlevi nesnesini alır.
`insert`	Öğeleri ekler.
`key_eq`	Depolanan karşılaştırma işlevi nesnesini alır.
`load_factor`	Demet başına ortalama öğeyi sayar.
`max_bucket_count`	En yüksek demet sayısını alır.
`max_load_factor`	Demet başına en yüksek öğe sayısını alır veya ayarlar.
`max_size`	Denetlenen dizinin en büyük boyutunu alır.
`rehash`	Karma tabloyu yeniden oluşturur.
`size`	Öğe sayısını sayar.
`swap`	İki kapsayıcının içeriğinin yerini değiştirir.
`unordered_set`	Bir kapsayıcı nesnesi oluşturur.

İşleçler

Veri Akışı Adı	Açıklama
`unordered_set::operator=`	Bir karma tabloya kopyalar.

Açıklamalar

nesnesi, depolanan iki nesne, türünde bir karşılaştırma işlevi nesnesi ve türünde unordered_set::key_equal bir karma işlev nesnesi çağırarak denetlediği sırayı unordered_set::hashersıralar. Üye işlevini çağırarak ilk depolanan nesneye erişiyor ve üye işlevini unordered_set::key_eq()unordered_set::hash_function()çağırarak ikinci depolanmış nesneye erişiyorsunuz. Özellikle, tüm değerler X ve Y türü Keyiçin, çağrısı key_eq()(X, Y) yalnızca iki bağımsız değişken değerinin eşdeğer sıralamaya sahip olması durumunda true döndürür; çağrı hash_function()(keyval) türündeki size_tdeğerlerin dağılımını verir. Sınıf şablonu unordered_multiset Sınıfı'nın aksine, türündeki unordered_set bir nesne, denetlenen dizinin herhangi iki öğesi için her zaman false olmasını sağlar key_eq()(X, Y) . (Anahtarlar benzersizdir.)

Nesne ayrıca, demet başına istenen ortalama öğe sayısını belirten en yüksek yük faktörünü depolar. Bir öğe eklenmesi en yüksek yük faktörünü aşmaya neden oluyorsa unordered_set::load_factor() , kapsayıcı demet sayısını artırır ve karma tabloyu gerektiği gibi yeniden oluşturur.

Denetlenen dizideki öğelerin gerçek sırası karma işleve, karşılaştırma işlevine, ekleme sırasına, en yüksek yük faktörüne ve geçerli demet sayısına bağlıdır. Denetimli dizideki öğelerin sırasını genel olarak tahmin edebilirsiniz. Ancak, eşdeğer sıralamaya sahip öğelerin herhangi bir alt kümesinin her zaman denetlenen dizide bitişik olduğundan emin olabilirsiniz.

nesnesi, türündeki unordered_set::allocator_typebir depolanmış ayırıcı nesnesi aracılığıyla denetlediğinden sıra için depolama ayırır ve serbesttir. Böyle bir ayırıcı nesne, türünde allocatorbir nesneyle aynı dış arabirime sahip olmalıdır. Kapsayıcı nesnesi atandığında depolanan ayırıcı nesnesi kopyalanmaz.

`unordered_set::allocator_type`

Depolamayı yönetmek için bir ayırıcı türü.

typedef Alloc allocator_type;

Açıklamalar

türü, şablon parametresi Allociçin bir eş anlamlıdır.

Örnek

// 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`

Denetlenen sıranın veya demetin başlangıcını belirtir.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parametreler

nbucket
Demet numarası.

Açıklamalar

İlk iki üye işlevi, dizinin ilk öğesine işaret eden bir ileriye doğru yineleyici döndürür (veya boş bir dizinin sonunun hemen ötesinde). Son iki üye işlevi, demetin ilk öğesini (veya boş bir demetin nbucket sonunun hemen ötesinde) işaret eden ileriye doğru bir yineleyici döndürür.

Örnek

// 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`

Bir anahtar değeri için demet numarasını alır.

size_type bucket(const Key& keyval) const;

Parametreler

keyval
Eşlenecek anahtar değeri.

Açıklamalar

Üye işlevi şu anda anahtar değerine keyvalkarşılık gelen demet numarasını döndürür.

Örnek

// 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`

Demet sayısını alır.

size_type bucket_count() const;

Açıklamalar

Üye işlevi geçerli demet sayısını döndürür.

Örnek

// 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`

Demet boyutunu alır

size_type bucket_size(size_type nbucket) const;

Parametreler

nbucket
Demet numarası.

Açıklamalar

Üye işlevleri, demet numarasının nbucketboyutunu döndürür.

Örnek

// 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`

Aralıktaki ilk öğeyi ele alan bir const yineleyici döndürür.

const_iterator cbegin() const;

Dönüş Değeri

Aralığın const ilk öğesini veya boş aralığın sonunun hemen ötesindeki konumu gösteren ileri erişim yineleyicisi (boş aralık için). cbegin() == cend()

Açıklamalar

değerinin cbegindönüş değeriyle, aralıktaki öğeler değiştirilemez.

Dönüş değerinin olduğunu const_iteratorgaranti etmek için üye işlevinin begin() yerine bu üye işlevini kullanabilirsiniz. Genellikle, aşağıdaki örnekte gösterildiği gibi tür kesinti anahtar sözcüğüyle auto birlikte kullanılır. Örnekte, ve cbegin()destekleyen herhangi bir türde begin() değiştirilebilir (non- const) kapsayıcısı olduğunu düşününContainer.

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

// i2 isContainer<T>::const_iterator

`cend`

Bir const aralıktaki son öğenin hemen ötesindeki konumu ele alan bir yineleyici döndürür.

const_iterator cend() const;

Dönüş Değeri

const Aralığın sonunun hemen ötesine işaret eden ileri erişim yineleyicisi.

Açıklamalar

cend bir yineleyicinin aralığının sonunu geçip geçmediğini test etmek için kullanılır.

Dönüş değerinin olduğunu const_iteratorgaranti etmek için üye işlevinin end() yerine bu üye işlevini kullanabilirsiniz. Genellikle, aşağıdaki örnekte gösterildiği gibi tür kesinti anahtar sözcüğüyle auto birlikte kullanılır. Örnekte, ve cend()destekleyen herhangi bir türde end() değiştirilebilir (non- const) kapsayıcısı olduğunu düşününContainer.

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

// i2 isContainer<T>::const_iterator

tarafından cend döndürülen değer başvurulmamalıdır.

`clear`

Tüm öğeleri kaldırır.

void clear();

Açıklamalar

Üye işlevi , çağrısında bulunurunordered_set::erase( unordered_set::begin()unordered_set::end()). Daha fazla bilgi için bkz. unordered_set::erase, unordered_set::begin ve unordered_set::end.

Örnek

// 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`

Denetlenen dizi için bir sabit yineleyici türü.

typedef T1 const_iterator;

Açıklamalar

türü, denetlenen dizi için sabit ileriye doğru yineleyici olarak hizmet veren bir nesneyi açıklar. Burada, uygulama tanımlı türü T1için bir eş anlamlı olarak açıklanmıştır.

Örnek

// 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`

Denetlenen dizi için bir sabit demet yineleyici türü.

typedef T5 const_local_iterator;

Açıklamalar

türü, bir demet için sabit ileriye doğru yineleyici görevi görecek bir nesneyi açıklar. Burada, uygulama tanımlı türü T5için bir eş anlamlı olarak açıklanmıştır.

Örnek

// 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`

Bir öğe için sabit bir işaretçi türü.

typedef Alloc::const_pointer const_pointer;

Açıklamalar

türü, denetlenen sıranın bir öğesine sabit işaretçi işlevi gösterebilen bir nesneyi açıklar.

Örnek

// 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`

Bir öğe için sabit bir başvuru türü.

typedef Alloc::const_reference const_reference;

Açıklamalar

türü, denetlenen sıranın bir öğesine sabit başvuru işlevi görecek bir nesneyi açıklar.

Örnek

// 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`

içinde unordered_setbelirtilen anahtara sahip bir öğe olup olmadığını denetler.

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

Parametreler

K
Anahtarın türü.

Key
Aranacak öğenin anahtar değeri.

Dönüş Değeri

true öğesi kapsayıcıda bulunursa; false yoksa.

Açıklamalar

contains() C++20 sürümünde yenidir. Bunu kullanmak için /std:c++20 veya üzeri derleyici seçeneğini belirtin.

template<class K> bool contains(const K& key) const yalnızca saydamsa key_compare aşırı yükleme çözümlemeye katılır.

Örnek

// 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`

Belirtilen bir anahtar ile eşleşen öğe sayısını bulur.

size_type count(const Key& keyval) const;

Parametreler

keyval
Aranacak anahtar değeri.

Açıklamalar

üye işlevi, ile unordered_set::equal_range(keyval)sınırlandırılan aralıktaki öğe sayısını döndürür.

Örnek

// 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`

İki öğe arasındaki işaretli mesafenin türü.

typedef T3 difference_type;

Açıklamalar

İmzalı tamsayı türü, denetlenen dizideki iki öğeden herhangi birinin adresleri arasındaki farkı temsil eden bir nesneyi açıklar. Burada, uygulama tanımlı türü T3için bir eş anlamlı olarak açıklanmıştır.

Örnek

// 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`

Yerinde derlenmiş bir öğe ekler (kopyalama veya taşıma işlemi yapılmaz).

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

Parametreler

args
değeri eşdeğer sıralanmış bir öğe içermediği sürece içine unordered_set eklenecek bir öğe oluşturmak için iletilen bağımsız değişkenler.

Dönüş Değeri

bool Bir pair ekleme yapıldıysa bileşeni true, anahtarı sıralamada eşdeğer bir değere sahip olan ve yineleyici bileşeni yeni öğenin eklendiği adresi veya öğenin zaten bulunduğu adresi döndüren bir öğe içeriyorsa false unordered_set döndürür.

Bu üye işlevi pr.firsttarafından döndürülen bir çiftin pr yineleyici bileşenine erişmek için kullanın ve başvuruyu geri almak için kullanın*(pr.first). Bu üye işlevi tarafından döndürülen bir çiftin bileşenine erişmek bool için kullanınpr.second.pr

Açıklamalar

Bu işlev tarafından hiçbir yineleyici veya başvuru geçersiz kılınmamış.

Ekleme sırasında, kapsayıcının karma işlevinde bir özel durum oluşursa, kapsayıcı değiştirilmez. Karma işlevinde özel durum oluşturulursa sonuç tanımlanmamış olur.

Kod örneği için bkz set::emplace. .

`emplace_hint`

Yerleştirme ipucuyla yerinde (hiçbir kopyalama veya taşıma işlemi gerçekleştirilmemiş) bir öğe ekler.

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

Parametreler

args
öğesine eklenecek unordered_set bir öğe oluşturmak için iletilen bağımsız değişkenler, zaten bu öğeyi içermiyorsa unordered_set veya daha genel olarak, anahtarı eşdeğer sıralı olan bir öğe içermiyorsa.

where
Doğru ekleme noktasını aramaya başlama yeri hakkında bir ipucu.

Dönüş Değeri

Yeni eklenen öğeye bir yineleyici.

Öğe zaten var olduğundan ekleme başarısız olduysa, var olan öğeye bir yineleyici döndürür.

Açıklamalar

Bu işlev tarafından hiçbir yineleyici veya başvuru geçersiz kılınmamış.

Ekleme sırasında, kapsayıcının karma işlevinde bir özel durum oluşursa, kapsayıcı değiştirilmez. Karma işlevinde özel durum oluşturulursa sonuç tanımlanmamış olur.

Kod örneği için bkz set::emplace_hint. .

`empty`

Bir öğe olup olmadığını sınar.

bool empty() const;

Açıklamalar

Üye işlevi boş denetimli bir dizi için true döndürür.

Örnek

// 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`

Denetlenen dizinin bitişini belirtir.

iterator end();

const_iterator end() const;

local_iterator end(size_type nbucket);

const_local_iterator end(size_type nbucket) const;

Parametreler

nbucket
Demet numarası.

Açıklamalar

İlk iki üye işlevi, sıranın sonunun hemen ötesine işaret eden ileriye doğru bir yineleyici döndürür. Son iki üye işlevi, demet nbucketsonunun hemen ötesine işaret eden ileriye doğru bir yineleyici döndürür.

Örnek

// 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`

Belirtilen bir anahtarla eşleşen aralığı bulur.

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

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

Parametreler

keyval
Aranacak anahtar değeri.

Açıklamalar

Üye işlevi, ile eşdeğer sıralamaya keyvalsahip denetimli dizinin yalnızca bu öğelerini sınırlayan bir çift yineleyici X[X.first, X.second) döndürür. Böyle bir öğe yoksa, her iki yineleyici de olur end().

Örnek

// 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`

Belirtilen konumlardan bir öğeyi veya bir unordered_set öğe aralığını kaldırır veya belirtilen bir anahtarla eşleşen öğeleri kaldırır.

iterator erase(const_iterator Where);

iterator erase(const_iterator First, const_iterator Last);

size_type erase(const key_type& Key);

Parametreler

Where
Kaldırılacak öğenin konumu.

First
Kaldırılacak ilk öğenin konumu.

Last
Kaldırılacak son öğenin hemen ötesinde konumlandırın.

Key
Kaldırılacak öğelerin anahtar değeri.

Dönüş Değeri

İlk iki üye işlevi için, kaldırılan öğelerin ötesinde kalan ilk öğeyi belirten çift yönlü bir yineleyici veya böyle bir öğe yoksa öğesinin unordered_set sonu olan bir öğe.

Üçüncü üye işlevi için, öğesinden unordered_setkaldırılan öğe sayısını döndürür.

Açıklamalar

Kod örneği için bkz . set::erase.

`find`

Belirtilen bir anahtarla eşleşen bir öğeyi bulur.

const_iterator find(const Key& keyval) const;

Parametreler

keyval
Aranacak anahtar değeri.

Açıklamalar

Üye işlevi döndürür unordered_set::equal_range(keyval).first.

Örnek

// 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`

Depolanan ayırıcı nesnesini alır.

Alloc get_allocator() const;

Açıklamalar

Üye işlevi depolanan ayırıcı nesnesini döndürür.

Örnek

// 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`

Depolanan karma işlevi nesnesini alır.

Hash hash_function() const;

Açıklamalar

Üye işlevi depolanan karma işlev nesnesini döndürür.

Örnek

// 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`

Karma işlevin türü.

typedef Hash hasher;

Açıklamalar

türü, şablon parametresi Hashiçin bir eş anlamlıdır.

Örnek

// 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`

içine bir öğe veya öğe unordered_setaralığı ekler.

// (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);

Parametreler

Val
anahtarı eşdeğer sıralanmış bir öğe içermediği sürece içine unordered_set eklenecek öğenin değeri.

Where
Doğru ekleme noktasını aramaya başlanması gereken yer.

ValTy
öğesini oluşturmak value_typeiçin kullanabileceği bağımsız değişken türünü unordered_set belirten şablon parametresi ve bağımsız değişken olarak perfect-forwardsVal.

First
Kopyalanacak ilk öğenin konumu.

Last
Kopyalanacak son öğenin hemen ötesindeki konum.

InputIterator
Nesne oluşturmak value_type için kullanılabilecek bir tür öğelerini işaret eden bir giriş yineleyicisinin gereksinimlerini karşılayan şablon işlevi bağımsız değişkeni.

IList
initializer_list Öğelerin kopyalandığı yer.

Dönüş Değeri

Tek öğeli üye işlevleri (1) ve (2), ekleme yapıldığında bileşeni true olan bir pair bool , anahtarı sıralamada eşdeğer bir değere sahip olan bir öğe içeriyorsa false unordered_set döndürür. Dönüş-değer çiftinin yineleyici bileşeni, bileşen ise bool yeni eklenen öğeye veya bileşen trueise mevcut öğeye bool işaret eder false.

İpucuyla tek öğeli üye işlevleri (3) ve (4), yeni öğenin veya eşdeğer anahtara sahip bir öğe zaten varsa mevcut öğeye eklendiği unordered_set konumu gösteren bir yineleyici döndürür.

Açıklamalar

Bu işlev tarafından hiçbir yineleyici, işaretçi veya başvuru geçersiz kılınmamış.

Yalnızca bir öğenin eklenmesi sırasında, kapsayıcının karma işlevinde bir özel durum oluşursa, kapsayıcının durumu değiştirilmez. Karma işlevinde özel durum oluşturulursa sonuç tanımlanmamış olur. Birden çok öğe eklenirken, bir özel durum oluşturulursa kapsayıcı belirtilmemiş ancak geçerli bir durumda bırakılır.

Tek öğeli üye işlevleri tarafından döndürülen bir pair pr öğesinin yineleyici bileşenine erişmek için öğesini kullanarak pr.firstdöndürülen çiftin içinde yineleyiciye başvuruda bulunun, kullanın*pr.first ve size bir öğe sağlayın. Bileşene bool erişmek için kullanın pr.second. Örnek için bu makalenin devamında yer alan örnek koda bakın.

value_type Kapsayıcının türü, kapsayıcıya ait olan bir tür tanımıdır ve küme unordered_set<V>::value_type için türüdürconst V.

Aralık üye işlevi (5), öğe değerlerinin dizisini aralıktaki [First, Last)bir unordered_set yineleyici tarafından adreslenen her öğeye karşılık gelen bir öğesine ekler; bu nedenle Last eklenmez. Kapsayıcı üyesi işlevi end() , kapsayıcıdaki son öğeden hemen sonraki konuma başvurur; örneğin, deyimi s.insert(v.begin(), v.end()); tüm öğelerini v içine seklemeye çalışır. Yalnızca aralıkta benzersiz değerlere sahip öğeler eklenir; yinelenenler yoksayılır. Hangi öğelerin reddedildiğini gözlemlemek için öğesinin tek öğeli sürümlerini insertkullanın.

Başlatıcı listesi üye işlevi (6), öğeleri içine unordered_setkopyalamak için bir initializer_list kullanır.

Yerinde inşa edilmiş bir öğenin eklenmesi için (başka bir deyişle, hiçbir kopyalama veya taşıma işlemi gerçekleştirilmez), bkz set::emplace . ve set::emplace_hint.

Kod örneği için bkz set::insert. .

`iterator`

Bir unordered_set öğeleri okuyabilen sabit ileriye doğru yineleyici sağlayan bir tür.

typedef implementation-defined iterator;

Örnek

Yineleyici bildirme ve kullanma örneği için begin örneğine bakın.

`key_eq`

Depolanan karşılaştırma işlevi nesnesini alır.

Pred key_eq() const;

Açıklamalar

Üye işlevi, depolanan karşılaştırma işlevi nesnesini döndürür.

Örnek

// 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`

Karşılaştırma işlevinin türü.

typedef Pred key_equal;

Açıklamalar

türü, şablon parametresi Prediçin bir eş anlamlıdır.

Örnek

// 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`

Bir sıralama anahtarının türü.

typedef Key key_type;

Açıklamalar

türü, şablon parametresi Keyiçin bir eş anlamlıdır.

Örnek

// 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`

Demet başına ortalama öğeyi sayar.

float load_factor() const;

Açıklamalar

Üye işlevi, demet başına ortalama öğe sayısı olan unordered_set::size() / (float)unordered_set::bucket_count() döndürür.(float)

Örnek

// 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`

Demet yineleyici türü.

typedef T4 local_iterator;

Açıklamalar

türü, bir demet için ileriye doğru yineleyici olarak hizmet veren bir nesneyi açıklar. Burada, uygulama tanımlı türü T4için bir eş anlamlı olarak açıklanmıştır.

Örnek

// 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`

En yüksek demet sayısını alır.

size_type max_bucket_count() const;

Açıklamalar

Üye işlevi şu anda izin verilen en fazla demet sayısını döndürür.

Örnek

// 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`

Demet başına en yüksek öğe sayısını alır veya ayarlar.

float max_load_factor() const;

void max_load_factor(float factor);

Parametreler

factor
Yeni maksimum yük faktörü.

Açıklamalar

İlk üye işlevi depolanan en yüksek yük faktörünü döndürür. İkinci üye işlevi depolanan en yüksek yük faktörünü ile factordeğiştirir.

Örnek

// 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`

Denetlenen dizinin en büyük boyutunu alır.

size_type max_size() const;

Açıklamalar

üye işlevi, nesnenin denetleyebileceği en uzun dizinin uzunluğunu döndürür.

Örnek

// 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=`

Bir karma tabloya kopyalar.

unordered_set& operator=(const unordered_set& right);

unordered_set& operator=(unordered_set&& right);

Parametreler

right
içine unordered_set kopyalanan unordered_set.

Açıklamalar

bir unordered_setiçindeki mevcut öğeleri sildikten sonra içeriğini operator= right unordered_setiçine kopyalar veya taşır.

Örnek

// 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`

Bir öğe için bir işaretçi türü.

typedef Alloc::pointer pointer;

Açıklamalar

türü, denetlenen dizinin bir öğesine işaretçi işlevi gösterebilen bir nesneyi açıklar.

Örnek

// 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`

Bir öğe için bir başvuru türü.

typedef Alloc::reference reference;

Açıklamalar

türü, denetlenen sıranın bir öğesine başvuru olarak görev yapabilecek bir nesneyi açıklar.

Örnek

// 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`

Karma tabloyu yeniden oluşturur.

void rehash(size_type nbuckets);

Parametreler

nbuckets
İstenen demet sayısı.

Açıklamalar

Üye işlevi, demet sayısını en az nbuckets olacak şekilde değiştirir ve karma tabloyu gerektiği gibi yeniden oluşturur.

Örnek

// 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`

Öğe sayısını sayar.

size_type size() const;

Açıklamalar

Üye işlevi, denetlenen sıranın uzunluğunu döndürür.

Örnek

// 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`

İki öğe arasındaki işaretsiz bir mesafenin türü.

typedef T2 size_type;

Açıklamalar

İşaretsiz tamsayı türü, denetlenen herhangi bir dizinin uzunluğunu temsil eden bir nesneyi açıklar. Burada, uygulama tanımlı türü T2için bir eş anlamlı olarak açıklanmıştır.

Örnek

// 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`

İki kapsayıcının içeriğinin yerini değiştirir.

void swap(unordered_set& right);

Parametreler

right
Takas için kapsayıcı.

Açıklamalar

Üye işlevi, ve arasında *this rightdenetlenen dizileri değiştirir. ise unordered_set::get_allocator() == right.get_allocator(), bunu sabit süre içinde yapar, yalnızca türündeki Trdepolanan nitelikler nesnesini kopyalamanın bir sonucu olarak bir özel durum oluşturur ve denetimli iki dizideki öğeleri atayan hiçbir başvuruyu, işaretçiyi veya yineleyiciyi geçersiz kılmaz. Aksi takdirde, denetlenen iki dizideki öğe sayısıyla orantılı olarak bir dizi öğe ataması ve oluşturucu çağrısı gerçekleştirir.

Örnek

// 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`

Bir kapsayıcı nesnesi oluşturur.

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());

Parametreler

InputIterator
Yineleyici türü.

Al
Depolanacak ayırıcı nesne.

Comp
Depolanacak karşılaştırma işlevi nesnesi.

Hash
Depolanacak karma işlev nesnesi.

bucket_count
En düşük demet sayısı.

Right
Kopyalanacak kapsayıcı.

IList
initializer_list Kopyalanacak öğeleri içeren.

Açıklamalar

İlk oluşturucu tarafından Rightdenetlenen dizinin bir kopyasını belirtir. İkinci oluşturucu boş bir denetlenmiş dizi belirtir. Üçüncü oluşturucu, dördüncü ile sekizinci oluşturucuları arasında taşıyarak Right dizinin bir kopyasını belirtir. Kopyalanacak öğeleri belirtmek için bir initializer_list kullanır. Dokuzuncu oluşturucu, öğe değerlerinin[first, last) sırasını ekler.

Ayrıca, tüm oluşturucular çeşitli depolanmış değerleri başlatır. Kopya oluşturucu için değerler kaynağından Rightalınır. Aksi durumda:

En az demet sayısı, varsa bağımsız değişkenidir bucket_count; aksi takdirde burada uygulama tanımlı değer olarak tanımlanan varsayılan değerdir N0.

Karma işlev nesnesi, varsa bağımsız değişkenidir Hash; aksi takdirde olur Hash().

Karşılaştırma işlevi nesnesi, varsa bağımsız değişkenidir Comp; aksi takdirde olur Comp().

Ayırıcı nesnesi, varsa bağımsız değişkenidir Al; aksi takdirde olur Alloc().

`value_type`

Öğenin türü.

typedef Key value_type;

Açıklamalar

türü, denetlenen dizinin bir öğesini açıklar.

Örnek

// 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]

Aracılığıyla paylaş

unordered_set Sınıf

Sözdizimi

Parametreler

Üyeler

Tür tanımları

İşlevler

İşleçler

Açıklamalar

unordered_set::allocator_type

Açıklamalar

Örnek

begin

Parametreler

Açıklamalar

Örnek

bucket

Parametreler

Açıklamalar

Örnek

bucket_count

Açıklamalar

Örnek

bucket_size

Parametreler

Açıklamalar

Örnek

cbegin

Dönüş Değeri

Açıklamalar

cend

Dönüş Değeri

Açıklamalar

clear

Açıklamalar

Örnek

const_iterator

Açıklamalar

Örnek

const_local_iterator

Açıklamalar

Örnek

const_pointer

Açıklamalar

Örnek

const_reference

Açıklamalar

Örnek

contains

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

count

Parametreler

Açıklamalar

Örnek

difference_type

Açıklamalar

Örnek

emplace

Parametreler

Dönüş Değeri

Açıklamalar

emplace_hint

Parametreler

Dönüş Değeri

Açıklamalar

empty

Açıklamalar

Örnek

end

Parametreler

Açıklamalar

Örnek

equal_range

Parametreler

Açıklamalar

Örnek

erase

`unordered_set` Sınıf

`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`