unordered_multimap Sınıfı

Makale
10/12/2023

Sınıf şablonu, türünde std::pair<const Key, Ty>öğ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 bir demette herhangi bir öğe çiftinin eşdeğer sıralamaya sahip olup olmadığını belirleyen bir karşılaştırma işlevi vardır. Her bir öğe iki nesne, bir sıralama anahtarı ve 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. Ayrıca, bir öğe eklenmesi hiçbir yineleyiciyi geçersiz kılmaz; bir öğenin kaldırılması yalnızca bu kaldırılan öğeyi gösteren yineleyicileri geçersiz kılar.

Sözdizimi

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

Parametreler

Anahtar
Anahtar türü.

Ty
Eşlenen tür.

Karma
Karma işlev nesne türü.

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

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

Üyeler

Tür Tanımlaması	Tanım
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ü.
Yineleyici	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ü.
mapped_type	Her bir anahtar ile ilişkili bir eşlenen değer türü.
Işaretçi	Bir öğe için bir işaretçi türü.
Başvuru	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ü.

Üye İşlevi	Tanım
Başlamak	Denetlenen dizinin başlangıcını belirtir.
Kova	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.
Temizleyin	Tüm öğeleri kaldırır.
C++20 içerir	içinde `unordered_multimap`belirtilen anahtara sahip bir öğe olup olmadığını denetler.
count	Belirtilen bir anahtar ile eşleşen öğe sayısını bulur.
yer değiştirme	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.
Son -unda	Denetlenen dizinin bitişini belirtir.
equal_range	Belirtilen bir anahtarla eşleşen aralığı bulur.
Silmek	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.
Ekle	Öğ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.
Boyutu	Öğe sayısını sayar.
Takas	İki kapsayıcının içeriğinin yerini değiştirir.
unordered_multimap	Bir kapsayıcı nesnesi oluşturur.

Operator	Tanım
unordered_multimap::operator=	Bir karma tabloya kopyalar.

Açıklamalar

nesnesi, unordered_multimap::key_equal türünde bir karşılaştırma işlevi nesnesi ve unordered_multimap::hasher türünde bir karma işlev nesnesi olmak üzere depolanan iki nesneyi çağırarak denetlediği sırayı sıralar. unordered_multimap::key_eq üye işlevini çağırarak ilk depolanmış nesneye erişin ve unordered_multimap::hash_function()() üye işlevini çağırarak ikinci depolanan nesneye erişin. Ö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_map Sınıf'ın aksine, türündeki unordered_multimap bir nesne denetimli dizinin herhangi iki öğesi için her zaman false olmasını sağlamaz key_eq()(X, Y) . (Anahtarlarının benzersiz olması gerekmez.)

Nesne ayrıca, demet başına istenen ortalama öğe sayısını belirten en yüksek yük faktörünü depolar. Öğe eklemek unordered_multimap::load_factor() en yüksek yük faktörünü aşmasına neden oluyorsa, 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. Denetlenen dizideki öğelerin sırasını genelde tahmin edemezsiniz. Ancak, eşdeğer sıralamaya sahip öğelerin herhangi bir alt kümesinin her zaman denetlenen dizide bitişik olduğundan emin olabilirsiniz.

nesnesi, unordered_multimap::allocator_type türündeki bir 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. Depolanan ayırıcı nesnenin kapsayıcı nesne atandığında kopyalanmayacağını unutmayın.

Gereksinimler

Üst Bilgi:<unordered_map>

Ad alanı: std

unordered_multimap::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_map__unordered_multimap_allocator_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

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

    Mymap::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

unordered_multimap::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, demet nbucket'in ilk öğesini (veya boş bir demetin sonunun hemen ötesinde) işaret eden ileriye doğru bir yineleyici döndürür.

Örnek

// std__unordered_map__unordered_multimap_begin.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect first two items " [c 3] [b 2]"
    Mymap::iterator it2 = c1.begin();
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    ++it2;
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2]
[a, 1]

unordered_multimap::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, anahtar değerine karşılık gelen demet numarasını döndürür.

Örnek

// std__unordered_map__unordered_multimap_bucket.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// display buckets for keys
    Mymap::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, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1

unordered_multimap::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_map__unordered_multimap_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
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

unordered_multimap::bucket_size

Demet boyutunu alır

size_type bucket_size(size_type nbucket) const;

Parametreler

nbucket
Demet numarası.

Açıklamalar

Üye işlevleri, demet sayısı nbucket boyutunu döndürür.

Örnek

// std__unordered_map__unordered_multimap_bucket_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// display buckets for keys
    Mymap::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, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1

unordered_multimap::cbegin

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

const_iterator cbegin() const;

İade 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 otomatik tür kesinti anahtar sözcüğüyle 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 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

unordered_multimap::cend

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

const_iterator cend() const;

İade 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 otomatik tür kesinti anahtar sözcüğüyle 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 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

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

unordered_multimap::clear

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

void clear();

Açıklamalar

Üye işlevi unordered_multimap::erase (unordered_multimap::begin(),unordered_multimap::end()) öğesini çağırır.

Örnek

// std__unordered_map__unordered_multimap_clear.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

// display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

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

    return (0);
    }

[c, 3] [b, 2] [a, 1]
size == 0
empty() == true

[e, 5] [d, 4]
size == 2
empty() == false

unordered_multimap::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_map__unordered_multimap_const_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::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_map__unordered_multimap_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[a, 1]

unordered_multimap::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_map__unordered_multimap_const_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::const_pointer p = &*it;
        std::cout << " [" << p->first << ", " << p->second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::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_map__unordered_multimap_const_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

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

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::contains

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

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

Parametreler

Kahraman
Anahtarın türü.

key
Aranacak öğenin anahtar değeri.

İade Değeri

true öğesi kapsayıcıda bulunursa; false Aksi takdir -de.

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_map>
#include <iostream>

int main()
{
    std::unordered_multimap<int, bool> theUnorderedMultimap = {{0, false}, {1,true}};

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

    return 0;
}

true
false

unordered_multimap::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, aralıktaki unordered_multimap::equal_range(keyval) ile ayrılmış öğe sayısını döndürür.

Örnek

// std__unordered_map__unordered_multimap_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
count('A') == 0
count('b') == 1
count('C') == 0

unordered_multimap::d ifference_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_map__unordered_multimap_difference_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

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

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

    return (0);
    }

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

unordered_multimap::emplace

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

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

Parametreler

Args
içine eklenecek bir öğe oluşturmak için iletilen unordered_multimapbağımsız değişkenler.

İade Değeri

Yeni eklenen öğeye bir yineleyici.

Açıklamalar

Bu işlev, kapsayıcı öğelerine yapılan başvurular geçersiz kılınmasa da kapsayıcıdaki tüm yineleyicileri geçersiz kılabilir.

Bir öğenin value_type bir çifttir, böylece bir öğenin değeri ilk bileşen anahtar değerine eşit ve ikinci bileşen öğenin veri değerine eşit olan sıralı bir çift olur.

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 . multimap::emplace.

unordered_multimap::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_iterator where,
    Args&&... args);

Parametreler

Args
Sıralanmamış içine eklenecek bir öğe oluşturmak için iletilen bağımsız değişkenler.

Nerede
Doğru ekleme noktasını aramaya başlama yeriyle ilgili bir ipucu.

İade Değeri

Yeni eklenen öğeye bir yineleyici.

Açıklamalar

Bu işlev, kapsayıcı öğelerine yapılan başvurular geçersiz kılınmasa da kapsayıcıdaki tüm yineleyicileri geçersiz kılabilir.

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.

Bir öğenin value_type bir çifttir, böylece bir öğenin değeri ilk bileşen anahtar değerine eşit ve ikinci bileşen öğenin veri değerine eşit olan sıralı bir çift olur.

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

unordered_multimap::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_map__unordered_multimap_empty.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

// display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

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

    return (0);
    }

[c, 3] [b, 2] [a, 1]
size == 0
empty() == true

[e, 5] [d, 4]
size == 2
empty() == false

unordered_multimap::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 nbucket'in sonunun hemen ötesine işaret eden ileriye doğru bir yineleyici döndürür.

Örnek

// std__unordered_map__unordered_multimap_end.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect last two items " [a 1] [b 2]"
    Mymap::iterator it2 = c1.end();
    --it2;
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    --it2;
    std::cout << " [" << it2->first << ", " << it2->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::const_local_iterator lit = c1.end(c1.bucket('a'));
    --lit;
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[a, 1] [b, 2]
[a, 1]

unordered_multimap::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, yalnızca denetlenen dizinin keyval ile eşdeğer sıralamaya sahip olan öğ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_map__unordered_multimap_equal_range.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// display results of failed search
    std::pair<Mymap::iterator, Mymap::iterator> pair1 =
        c1.equal_range('x');
    std::cout << "equal_range('x'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << " [" << pair1.first->first
            << ", " << pair1.first->second << "]";
    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->first
            << ", " << pair1.first->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
equal_range('x'):
equal_range('b'): [b, 2]

unordered_multimap::erase

Bir unordered_multimap içindeki bir öğeyi veya öğe aralığını belirtilen konumlardan 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

Nerede
Kaldırılacak öğenin konumu.

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

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

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

İade 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 eşlemenin sonu olan bir öğe.

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

Açıklamalar

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

unordered_multimap::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 unordered_multimap::equal_range(keyval).first döndürür.

Örnek

// std__unordered_map__unordered_multimap_find.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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
    Mymap::iterator it = c1.find('b');
    std::cout << "find('b') == "
        << std::boolalpha << (it != c1.end())
        << ": [" << it->first << ", " << it->second << "]" << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
find('A') == false
find('b') == true: [b, 2]

unordered_multimap::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_map__unordered_multimap_get_allocator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

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

    Mymap::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

unordered_multimap::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_map__unordered_multimap_hash_function.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::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

unordered_multimap::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_map__unordered_multimap_hasher.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::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

unordered_multimap::insert

unordered_multimap bir öğe veya öğe aralığı 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
unordered_multimap eklenecek öğenin değeri.

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

Değer
unordered_multimap bir value_type öğesi oluşturmak için kullanabileceği bağımsız değişken türünü belirten şablon parametresi ve Val'i bağımsız değişken olarak mükemmel iletir.

Ilk
Kopyalanacak ilk öğenin konumu.

Son
Kopyalanacak son öğenin hemen ötesindeki konum.

InputIterator
Value_type nesneleri oluşturmak için kullanılabilecek bir türdeki öğeleri işaret eden bir giriş yineleyicisinin gereksinimlerini karşılayan şablon işlevi bağımsız değişkeni.

IList
Öğelerin kopyalandığı initializer_list .

İade Değeri

(1) ve (2) tek öğeli ekleme üye işlevleri, yeni öğenin unordered_multimap eklendiği konuma bir yineleyici döndürür.

İpucu olan tek öğeli üye işlevleri (3) ve (4), yeni öğenin unordered_multimap eklendiği konumu gösteren bir yineleyici döndürür.

Açıklamalar

Bu işlev tarafından hiçbir işaretçi veya başvuru geçersiz kılınmamış, ancak kapsayıcıdaki tüm yineleyicileri geçersiz kılabilir.

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.

Kapsayıcının value_type kapsayıcıya ait bir tür tanımıdır ve eşleme map<K, V>::value_type için ise şeklindedir pair<const K, V>. Öğenin değeri, ilk bileşenin anahtar değerine, ikinci bileşenin ise öğenin veri değerine eşit olduğu sıralı bir çifttir.

Aralık üye işlevi (5), öğe değerlerinin dizisini aralıktaki [First, Last)bir yineleyici tarafından ele alınan her öğeye karşılık gelen bir unordered_multimap ekler; bu nedenle Last eklenmez. Kapsayıcı üyesi işlevi end() , kapsayıcıdaki son öğeden hemen sonraki konuma başvurur; örneğin, deyimi m.insert(v.begin(), v.end()); tüm öğelerini v içine mekler.

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

Yerinde oluşturulan bir öğenin eklenmesi için (yani, hiçbir kopyalama veya taşıma işlemi gerçekleştirilmediğinden) bkz . unordered_multimap::emplace ve unordered_multimap::emplace_hint.

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

unordered_multimap::yineleyici

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

typedef T0 iterator;

Açıklamalar

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

Örnek

// std__unordered_map__unordered_multimap_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::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_map__unordered_multimap_key_eq.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::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

unordered_multimap::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_map__unordered_multimap_key_equal.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    Mymap::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

unordered_multimap::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_map__unordered_multimap_key_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]

unordered_multimap::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_multimap::size() / (float)unordered_multimap::bucket_count() döndürür.(float)

Örnek

// std__unordered_map__unordered_multimap_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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);
    }

unordered_multimap::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_map__unordered_multimap_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// inspect bucket containing 'a'
    Mymap::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << " [" << lit->first << ", " << lit->second << "]";

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[a, 1]

unordered_multimap::mapped_type

Her bir anahtar ile ilişkili bir eşlenen değer türü.

typedef Ty mapped_type;

Açıklamalar

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

Örnek

// std__unordered_map__unordered_multimap_mapped_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]

unordered_multimap::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_map__unordered_multimap_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
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

unordered_multimap::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

Faktörü
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ü faktörle değiştirir.

Örnek

// std__unordered_map__unordered_multimap_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
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

unordered_multimap::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_map__unordered_multimap_max_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

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

    return (0);
    }

max_size() == 536870911

unordered_multimap::operator=

Bir karma tabloya kopyalar.

unordered_multimap& operator=(const unordered_multimap& right);

unordered_multimap& operator=(unordered_multimap&& right);

Parametreler

Doğru
içine unordered_multimap kopyalanan unordered_multimap.

Açıklamalar

bir unordered_multimap mevcut öğeleri sildikten sonra, operator= içeriğini doğrudan unordered_multimap kopyalar veya taşır.

Örnek

// unordered_multimap_operator_as.cpp
// compile with: /EHsc
#include <unordered_multimap>
#include <iostream>

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

   v1.insert(pair<int, int>(1, 10));

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

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

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

unordered_multimap::p ointer

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_map__unordered_multimap_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::pointer p = &*it;
        std::cout << " [" << p->first << ", " << p->second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::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_map__unordered_multimap_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Mymap::reference ref = *it;
        std::cout << " [" << ref.first << ", " << ref.second << "]";
        }
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]

unordered_multimap::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_map__unordered_multimap_rehash.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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, 3] [b, 2] [a, 1]
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

unordered_multimap::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_map__unordered_multimap_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    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(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

// display contents " [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

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

    return (0);
    }

[c, 3] [b, 2] [a, 1]
size == 0
empty() == true

[e, 5] [d, 4]
size == 2
empty() == false

unordered_multimap::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_map__unordered_multimap_size_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;
    Mymap::size_type sz = c1.size();

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

    return (0);
    }

size == 0

unordered_multimap::swap

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

void swap(unordered_multimap& right);

Parametreler

Doğru
Takas için kapsayıcı.

Açıklamalar

Üye işlevi, denetimli dizileri ile sağ arasında *this değiştirir. unordered_multimap::get_allocator() == right.get_allocator(), bunu sabit bir süre içinde yapar, yalnızca türündeki Trdepolanan nitelikler nesnesini kopyalamanın bir sonucu olarak bir özel durum oluşturur ve denetlenen 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_map__unordered_multimap_swap.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    Mymap c2;

    c2.insert(Mymap::value_type('d', 4));
    c2.insert(Mymap::value_type('e', 5));
    c2.insert(Mymap::value_type('f', 6));

    c1.swap(c2);

// display contents " [f 6] [e 5] [d 4]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    swap(c1, c2);

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]

unordered_multimap::unordered_multimap

Bir kapsayıcı nesnesi oluşturur.

unordered_multimap(
    const unordered_multimap& Right);

explicit unordered_multimap(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Pred(),
    const Allocator& Al = Alloc());

unordered_multimap(
    unordered_multimap&& Right);

unordered_multimap(
    initializer_list<Type> IList);

unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count);

unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash);

unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key);

unordered_multimap(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key,
    const Allocator& Al);

template <class InputIterator>
unordered_multimap(
    InputIterator first,
    InputIterator last,
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Pred(),
    const Allocator& Al = Alloc());

Parametreler

InputIterator
Yineleyici türü.

Al
Depolanacak ayırıcı nesne.

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

Karma
Depolanacak karma işlev nesnesi.

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

Right
Kopyalanacak kapsayıcı.

IList
Öğelerin kopyalanacağı initializer_list.

Açıklamalar

İlk oluşturucu, Right tarafından denetlenen dizinin bir kopyasını belirtir. İkinci oluşturucu boş bir denetlenmiş dizi belirtir. Üçüncü oluşturucu. Sağ'a taşıyarak dizinin bir kopyasını belirtir. Dördüncü, beşinci, altıncı, yedinci ve sekizinci oluşturucular üyeler 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 Sağdan alınır. Aksi durumda:

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

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

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

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

Örnek

// std__unordered_map__unordered_multimap_construct.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

using namespace std;

using  Mymap = unordered_multimap<char, int> ;
int main()
{
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c2(8,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    c2.insert(Mymap::value_type('d', 4));
    c2.insert(Mymap::value_type('e', 5));
    c2.insert(Mymap::value_type('f', 6));

    // display contents " [f 6] [e 5] [d 4]"
    for (const auto& c : c2) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c3(c1.begin(),
        c1.end(),
        8,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >());

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c3) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    Mymap c4(move(c3));

    // display contents " [c 3] [b 2] [a 1]"
    for (const auto& c : c4) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Construct with an initializer_list
    unordered_multimap<int, char> c5({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } });
    for (const auto& c : c5) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size
    unordered_multimap<int, char> c6({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 4);
    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size and hash
    unordered_multimap<int, char, hash<char>> c7(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size, hash, and key_equal
    unordered_multimap<int, char, hash<char>, equal_to<char>> c8(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>(),
        equal_to<char>()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;

    // Initializer_list plus size, hash, key_equal, and allocator
    unordered_multimap<int, char, hash<char>, equal_to<char>> c9(
        { { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
        4,
        hash<char>(),
        equal_to<char>(),
        allocator<pair<const char, int> >()
    );

    for (const auto& c : c1) {
        cout << " [" << c.first << ", " << c.second << "]";
    }
    cout << endl;
}

[a, 1] [b, 2] [c, 3] [d, 4] [e, 5] [f, 6] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [5, g] [6, h] [7, i] [8, j] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2] [a, 1]

unordered_multimap::value_type

Öğenin türü.

typedef std::pair<const Key, Ty> value_type;

Açıklamalar

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

Örnek

// std__unordered_map__unordered_multimap_value_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>

typedef std::unordered_multimap<char, int> Mymap;
int main()
    {
    Mymap c1;

    c1.insert(Mymap::value_type('a', 1));
    c1.insert(Mymap::value_type('b', 2));
    c1.insert(Mymap::value_type('c', 3));

// display contents " [c 3] [b 2] [a 1]"
    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

// add a value and reinspect
    Mymap::key_type key = 'd';
    Mymap::mapped_type mapped = 4;
    Mymap::value_type val = Mymap::value_type(key, mapped);
    c1.insert(val);

    for (Mymap::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << " [" << it->first << ", " << it->second << "]";
    std::cout << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]

Ayrıca bkz.

<unordered_map>
Konteynerler
C++ Standart Kitaplığında İş Parçacığı Güvenliği
C++ Standart Kitaplığı Başvurusu

Aracılığıyla paylaş

unordered_multimap Sınıfı

Sözdizimi

Parametreler

Üyeler

Açıklamalar

Gereksinimler

unordered_multimap::allocator_type

Açıklamalar

Örnek

unordered_multimap::begin

Parametreler

Açıklamalar

Örnek

unordered_multimap::bucket

Parametreler

Açıklamalar

Örnek

unordered_multimap::bucket_count

Açıklamalar

Örnek

unordered_multimap::bucket_size

Parametreler

Açıklamalar

Örnek

unordered_multimap::cbegin

İade Değeri

Açıklamalar

unordered_multimap::cend

İade Değeri

Açıklamalar

unordered_multimap::clear

Açıklamalar

Örnek

unordered_multimap::const_iterator

Açıklamalar

Örnek

unordered_multimap::const_local_iterator

Açıklamalar

Örnek

unordered_multimap::const_pointer

Açıklamalar

Örnek

unordered_multimap::const_reference

Açıklamalar

Örnek

unordered_multimap::contains

Parametreler

İade Değeri

Açıklamalar

Örnek

unordered_multimap::count

Parametreler

Açıklamalar

Örnek

unordered_multimap::d ifference_type

Açıklamalar

Örnek

unordered_multimap::emplace

Parametreler

İade Değeri

Açıklamalar

unordered_multimap::emplace_hint

Parametreler

İade Değeri

Açıklamalar

unordered_multimap::empty

Açıklamalar

Örnek

unordered_multimap::end

Parametreler

Açıklamalar

Örnek

unordered_multimap::equal_range

Parametreler

Açıklamalar

Örnek

unordered_multimap::erase

Parametreler

İade Değeri