hash_multimap (STL/CLR)

Şablon sınıfı, çift yönlü erişime sahip öğelerin değişen uzunlukta dizisini denetleen bir nesneyi açıklar. Kapsayıcıyı hash_multimap bir öğe dizisini karma tablo olarak yönetmek için kullanırsınız, her tablo girişi çift yönlü bağlantılı düğüm listesini depolar ve her düğüm bir öğe depolar. Öğe, sırayı sıralamak için bir anahtardan ve sürüş için birlikte giden eşlenmiş bir değerden oluşur.

Aşağıdaki açıklamada aşağıdakiyle GValue aynıdır:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

konumu:

GKey , ikinci bir başvuru türü olmadığı sürece aynıdır Key ; bu durumda Key^

GMapped , ikinci bir başvuru türü olmadığı sürece aynıdır Mapped ; bu durumda Mapped^

Sözdizimi

template<typename Key,
    typename Mapped>
    ref class hash_multimap
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IHash<Gkey, GValue>
    { ..... };

Parametreler

Key
Denetlenen dizideki bir öğenin anahtar bileşeninin türü.

Mapped
Denetlenen dizideki bir öğenin diğer bileşeninin türü.

Gereksinimler

Üst bilgi:<cliext/hash_map>

Ad alanı: cliext

Bildirimler

Tür tanımı	Açıklama
hash_multimap::const_iterator	Denetlenen dizi için bir sabit yineleyici türü.
hash_multimap::const_reference	Bir öğe için sabit bir başvuru türü.
hash_multimap::const_reverse_iterator	Denetimli sıra için sabit bir ters yineleyici türü.
hash_multimap::difference_type	İki öğe arasındaki (büyük olasılıkla imzalı) uzaklık türü.
hash_multimap::generic_container	Kapsayıcı için genel arabirimin türü.
hash_multimap::generic_iterator	Kapsayıcının genel arabirimi için yineleyici türü.
hash_multimap::generic_reverse_iterator	Kapsayıcının genel arabirimi için ters yineleyici türü.
hash_multimap::generic_value	Kapsayıcının genel arabirimi için bir öğenin türü.
hash_multimap::hasher	Anahtar için karma temsilcisi.
hash_multimap::iterator	Denetlenen dizi için bir yineleyici türü.
hash_multimap::key_compare	İki anahtar için sıralama temsilcisi.
hash_multimap::key_type	Bir sıralama anahtarının türü.
hash_multimap::mapped_type	Her anahtarla ilişkili eşlenmiş değerin türü.
hash_multimap::reference	Bir öğe için bir başvuru türü.
hash_multimap::reverse_iterator	Denetimli sıra için ters yineleyicinin türü.
hash_multimap::size_type	İki öğe arasındaki (negatif olmayan) mesafenin türü.
hash_multimap::value_compare	İki öğe değeri için sıralama temsilcisi.
hash_multimap::value_type	Öğenin türü.

Üye işlevi	Açıklama
hash_multimap::begin	Denetlenen dizinin başlangıcını belirtir.
hash_multimap::bucket_count	Demet sayısını sayar.
hash_multimap::clear	Tüm öğeleri kaldırır.
hash_multimap::count	Belirtilen anahtarla eşleşen öğeleri sayar.
hash_multimap::empty	Bir öğe olup olmadığını sınar.
hash_multimap::end	Denetlenen dizinin bitişini belirtir.
hash_multimap::equal_range	Belirtilen bir anahtarla eşleşen aralığı bulur.
hash_multimap::erase	Belirtilen konumlardaki öğeleri kaldırır.
hash_multimap::find	Belirtilen bir anahtarla eşleşen bir öğeyi bulur.
hash_multimap::hash_delegate	Anahtar için karma temsilcisini kopyalar.
hash_multimap::hash_multimap	Bir kapsayıcı nesnesi oluşturur.
hash_multimap::insert	Öğeleri ekler.
hash_multimap::key_comp	İki anahtar için sıralama temsilcisini kopyalar.
hash_multimap::load_factor	Demet başına ortalama öğeyi sayar.
hash_multimap::lower_bound	Belirtilen anahtarla eşleşen aralığın başlangıcını bulur.
hash_multimap::make_value	Bir değer nesnesi oluşturur.
hash_multimap::max_load_factor	Demet başına en yüksek öğe sayısını alır veya ayarlar.
hash_multimap::rbegin	Ters denetimli sıranın başlangıcını belirtir.
hash_multimap::rehash	Karma tabloyu yeniden oluşturur.
hash_multimap::rend	Ters denetimli sıranın sonunu belirtir.
hash_multimap::size	Öğe sayısını sayar.
hash_multimap::swap	İki kapsayıcının içeriğinin yerini değiştirir.
hash_multimap::to_array	Denetimli diziyi yeni bir diziye kopyalar.
hash_multimap::upper_bound	Belirtilen anahtarla eşleşen aralığın sonunu bulur.
hash_multimap::value_comp	İki öğe değeri için sıralama temsilcisini kopyalar.

Operator	Açıklama
hash_multimap::operator=	Denetimli sıranın yerini alır.

Arabirimler

Arabirim	Açıklama
ICloneable	Nesneyi çoğaltma.
IEnumerable	Öğeler arasında sıralama.
ICollection	Öğe grubunu koruyun.
IEnumerable<T>	Yazılan öğeler arasında sıra.
ICollection<T>	Yazılan öğe grubunu koruyun.
IHash<Key, Value>	Genel kapsayıcıyı koruyun.

Açıklamalar

nesnesi, denetlediği sıra için çift yönlü bağlantılı bir listede ayrı düğümler olarak depolama ayırır ve serbesttir. Erişimi hızlandırmak için, nesne ayrıca listede (karma tablosu) çeşitli uzunlukta işaretçiler dizisi tutar ve listenin tamamını bir alt liste veya demet dizisi olarak etkili bir şekilde yönetir. Öğeleri, hiçbir zaman bir düğümün içeriğini başka bir düğüme kopyalayarak düğümler arasındaki bağlantıları değiştirerek sıralı olarak tuttuğu bir demete ekler. Bu, kalan öğeleri rahatsız etmeden öğeleri serbestçe ekleyebileceğiniz ve kaldırabileceğiniz anlamına gelir.

nesnesi, türündeki hash_set::key_comparedepolanmış bir temsilci nesnesini çağırarak denetlediği her demeti sıralar. hash_set oluştururken depolanan temsilci nesnesini belirtebilirsiniz; temsilci nesnesi belirtmezseniz, varsayılan karşılaştırmadır operator<=(key_type, key_type).

Üye işlevini hash_set::key_compçağırarak depolanan temsilci nesnesine erişebilirsiniz. Böyle bir temsilci nesnesi, türünde hash_set::key_typeanahtarlar arasında eşdeğer sıralama tanımlamalıdır. Başka bir deyişle, iki anahtar X ve Yiçin:

key_comp()(X, Y) her çağrıda aynı Boole sonucunu döndürür.

True key_comp()(X, Y) && key_comp()(Y, X) ise ve X Y eşdeğer sıralamaya sahip olduğu söylenir.

gibi operator<=(key_type, key_type)operator>=(key_type, key_type) davranan veya operator==(key_type, key_type) eşdeğer sıralamayı tanımlayan herhangi bir sıralama kuralı.

Kapsayıcı yalnızca anahtarları eşdeğer sıralamaya (ve aynı tamsayı değerine karmaya) sahip öğelerin bir demet içinde bitişik olmasını sağlar. Şablon sınıfından hash_map (STL/CLR) farklı olarak, şablon sınıfının hash_multimap bir nesnesi tüm öğeler için anahtarların benzersiz olmasını gerektirmez. (İki veya daha fazla anahtar eşdeğer sıralamaya sahip olabilir.)

nesnesi, türünde hash_set::hasherbir depolanmış temsilci nesnesi çağırarak belirli bir sıralama anahtarı içermesi gereken demeti belirler. Bu depolanan nesneye erişmek için üye işlevini hash_set::hash_delegate çağırarak anahtar değerine bağlı bir tamsayı değeri alırsınız. hash_set oluştururken depolanan temsilci nesnesini belirtebilirsiniz; temsilci nesnesi belirtmezseniz, varsayılan işlevidir System::Object::hash_value(key_type). Bu, tüm anahtarlar X ve Yiçin anlamına gelir:

hash_delegate()(X) her çağrıda aynı tamsayı sonucunu döndürür.

ve Y eşdeğer sıralamaya sahipseX, hash_delegate()(X) ile aynı tamsayı sonucunu hash_delegate()(Y)döndürmelidir.

Her öğe ayrı bir anahtar ve eşlenmiş bir değer içerir. Sıra, rastgele bir öğenin sabit sürede arama, ekleme ve kaldırma işlemlerine izin veren bir şekilde temsil edilir. Yani işlem sayısı, en azından en iyi durumlarda, dizideki öğe sayısından bağımsızdır. Ayrıca, öğ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ılabilir.

Ancak karma değerler tekdüzen olarak dağıtılamıyorsa karma tablo dejenere olabilir. Aşırı uçta (her zaman aynı değeri döndüren bir karma işlevi için), arama, ekleme ve kaldırma, dizideki öğe sayısıyla (doğrusal süre) orantılıdır. Kapsayıcı makul bir karma işlevi, ortalama demet boyutu ve karma tablo boyutu (toplam demet sayısı) seçmeye çalışır, ancak bu seçeneklerin herhangi birini veya tümünü geçersiz kılabilirsiniz. Bkz. örneğin, işlevleri hash_set::max_load_factor ve hash_set::rehash.

A hash_multimap , çift yönlü yineleyicileri destekler. Bu, denetlenen dizideki bir öğeyi belirten bir yineleyici verildiğinde bitişik öğelere adım atabileceğiniz anlamına gelir. Özel bir baş düğümü tarafından end()döndürülen yineleyiciye karşılık gelir. Varsa, denetimli dizideki son öğeye ulaşmak için bu yineleyiciyi geri alabilirsiniz. Baş düğüme ulaşmak için yineleyiciyi hash_multimap artırabilirsiniz ve ardından eşit olarak karşılaştırır end(). Ancak tarafından end()döndürülen yineleyicinin başvurularını kaldıramazsınız.

Doğrudan sayısal konumu verilen bir hash_multimap öğeye başvuramazsınız. Bunun için rastgele erişim yineleyicisi gerekir.

hash_multimap Yineleyici, ilişkili hash_multimap düğümünde bir tanıtıcı depolar ve bu da ilişkili kapsayıcısında bir tanıtıcı depolar. Yineleyicileri yalnızca ilişkili kapsayıcı nesneleriyle kullanabilirsiniz. Yineleyici hash_multimap , ilişkili hash_multimap düğümü ile ilişkili hash_multimapolduğu sürece geçerli kalır. Ayrıca geçerli bir yineleyicinin başvurusu kaldırılabilir. Eşit olmadığı sürece, öğe değerine erişmek veya değerini değiştirmek için end()kullanabilirsiniz.

Bir öğenin silinmesi veya kaldırılması, depolanmış değeri için yıkıcıyı çağırır. Kapsayıcıyı yok etmek tüm öğeleri siler. Bu nedenle, öğe türü ref sınıfı olan bir kapsayıcı, hiçbir öğenin kapsayıcıdan daha uzun yaşamasını sağlamaz. Ancak, bir tutamaç kapsayıcısı öğelerini yok etmez.

Üyeler

hash_multimap::begin

Denetlenen dizinin başlangıcını belirtir.

Sözdizimi

iterator begin();

Açıklamalar

Üye işlevi, denetlenen dizinin ilk öğesini veya boş bir dizinin sonunun hemen ötesinde belirten çift yönlü bir yineleyici döndürür. Denetimli sıranın current başlangıcını belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_hash_multimap_begin.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_multimap::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*++begin() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*begin() = [a 1]
*++begin() = [b 2]

hash_multimap::bucket_count

Demet sayısını sayar.

Sözdizimi

int bucket_count();

Açıklamalar

Üye işlevi geçerli demet sayısını döndürür. Karma tablosunun boyutunu belirlemek için bunu kullanırsınız.

Örnek

// cliext_hash_multimap_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1 = gcnew Myhash_multimap;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_multimap::clear

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

Sözdizimi

void clear();

Açıklamalar

Üye işlevi etkin bir şekilde öğesini çağırır erase(begin(), end()). Denetimli sıranın boş olduğundan emin olmak için bunu kullanırsınız.

Örnek

// cliext_hash_multimap_clear.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

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

hash_multimap::const_iterator

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

Sözdizimi

typedef T2 const_iterator;

Açıklamalar

türü, denetlenen dizi için sabit bir çift yönlü yineleyici görevi görecek belirtilmemiş türdeki T2 bir nesneyi açıklar.

Örnek

// cliext_hash_multimap_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("[{0} {1}] ", cit->first, cit->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::const_reference

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

Sözdizimi

typedef value_type% const_reference;

Açıklamalar

türü, bir öğeye sabit başvuruyu açıklar.

Örnek

// cliext_hash_multimap_const_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_multimap::const_reference cref = *cit;
        System::Console::Write("[{0} {1}] ", cref->first, cref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::const_reverse_iterator

Denetimli sıra için sabit bir ters yineleyici türü.

Sözdizimi

typedef T4 const_reverse_iterator;

Açıklamalar

türü, denetlenen dizi için sabit bir ters yineleyici görevi görecek belirtilmemiş türdeki T4 bir nesneyi açıklar.

Örnek

// cliext_hash_multimap_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_multimap::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("[{0} {1}] ", crit->first, crit->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::count

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

Sözdizimi

size_type count(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

üye işlevi, ile eşdeğer sıralamaya keysahip denetimli dizideki öğelerin sayısını döndürür. Belirtilen bir anahtarla eşleşen denetimli sırada bulunan öğelerin sayısını belirlemek için bunu kullanırsınız.

Örnek

// cliext_hash_multimap_count.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

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

hash_multimap::d ifference_type

İki öğe arasındaki imzalı uzaklık türleri.

Sözdizimi

typedef int difference_type;

Açıklamalar

Türü, büyük olasılıkla negatif öğe sayısını açıklar.

Örnek

// cliext_hash_multimap_difference_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_multimap::difference_type diff = 0;
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Myhash_multimap::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

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

hash_multimap::empty

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

Sözdizimi

bool empty();

Açıklamalar

Üye işlevi boş denetimli bir dizi için true döndürür. ile eşdeğerdir size() == 0. Boş olup olmadığını hash_multimap test etmek için bunu kullanırsınız.

Örnek

// cliext_hash_multimap_empty.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 3
empty() = False
size() = 0
empty() = True

hash_multimap::end

Denetlenen dizinin bitişini belirtir.

Sözdizimi

iterator end();

Açıklamalar

Üye işlevi, denetlenen sıranın sonunun hemen ötesine işaret eden çift yönlü bir yineleyici döndürür. Bunu, denetlenen sıranın sonunu belirten bir yineleyici elde etmek için kullanırsınız; denetlenen sıranın uzunluğu değişirse durumu değişmez.

Örnek

// cliext_hash_multimap_end.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_multimap::iterator it = c1.end();
    --it;
    --it;
    System::Console::WriteLine("*-- --end() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*--end() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

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

hash_multimap::equal_range

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

Sözdizimi

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

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

Üye işlevi bir çift yineleyici cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key))döndürür. Bunu, şu anda denetimli dizide belirtilen bir anahtarla eşleşen öğe aralığını belirlemek için kullanırsınız.

Örnek

// cliext_hash_multimap_equal_range.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
typedef Myhash_multimap::pair_iter_iter Pairii;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

[a 1] [b 2] [c 3]
equal_range(L'x') empty = True
[b 2]

hash_multimap::erase

Belirtilen konumlardaki öğeleri kaldırır.

Sözdizimi

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

Parametreler

first
Silinecek aralığın başlangıcı.

key
Silinecek anahtar değeri.

last
Silinecek aralığın sonu.

where
Silinecek öğe.

Açıklamalar

İlk üye işlevi tarafından whereişaret edilen denetlenen dizinin öğesini kaldırır ve kaldırılan öğenin ötesinde kalan ilk öğeyi belirten veya end() böyle bir öğe yoksa bir yineleyici döndürür. Tek bir öğeyi kaldırmak için bunu kullanırsınız.

İkinci üye işlevi, yarım açık aralıktaki [first, last)denetlenen dizinin öğelerini kaldırır ve kaldırılan öğelerin ötesinde kalan ilk öğeyi belirten veya end() böyle bir öğe yoksa bir yineleyici döndürür. Sıfır veya daha fazla bitişik öğeyi kaldırmak için bunu kullanırsınız.

Üçüncü üye işlevi, anahtarı ile eşdeğer sıralamaya keysahip denetimli dizinin herhangi bir öğesini kaldırır ve kaldırılan öğe sayısının sayısını döndürür. Bunu, belirtilen bir anahtarla eşleşen tüm öğeleri kaldırmak ve saymak için kullanırsınız.

Her öğe silme işlemi, denetlenen dizideki öğe sayısının logaritmasıyla orantılı olarak zaman alır.

Örnek

// cliext_hash_multimap_erase.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    cliext::hash_multimap<wchar_t, int> c1;
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'a', 1));
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'b', 2));
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::hash_multimap<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase an element and reinspect
    cliext::hash_multimap<wchar_t, int>::iterator it =
        c1.erase(c1.begin());
    System::Console::WriteLine("erase(begin()) = [{0} {1}]",
        it->first, it->second);

    // add elements and display " b c d e"
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::hash_multimap<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase all but end
    it = c1.end();
    it = c1.erase(c1.begin(), --it);
    System::Console::WriteLine("erase(begin(), end()-1) = [{0} {1}]",
        it->first, it->second);
    System::Console::WriteLine("size() = {0}", c1.size());

    // erase end
    System::Console::WriteLine("erase(L'x') = {0}", c1.erase(L'x'));
    System::Console::WriteLine("erase(L'e') = {0}", c1.erase(L'e'));
    return (0);
    }

[a 1] [b 2] [c 3]
erase(begin()) = [b 2]
[b 2] [c 3] [d 4] [e 5]
erase(begin(), end()-1) = [e 5]
size() = 1
erase(L'x') = 0
erase(L'e') = 1

hash_multimap::find

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

Sözdizimi

iterator find(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

Denetlenen dizideki en az bir öğe ile keyeşdeğer sıralamaya sahipse, üye işlevi bu öğelerden birini belirten bir yineleyici döndürür; aksi takdirde döndürür hash_multimap::end(). Şu anda denetimli dizide belirtilen bir anahtarla eşleşen bir öğeyi bulmak için bu öğeyi kullanırsınız.

Örnek

// cliext_hash_multimap_find.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());

    Myhash_multimap::iterator it = c1.find(L'b');
    System::Console::WriteLine("find {0} = [{1} {2}]",
        L'b', it->first, it->second);

    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

[a 1] [b 2] [c 3]
find A = False
find b = [b 2]
find C = False

hash_multimap::generic_container

Kapsayıcı için genel arabirimin türü.

Sözdizimi

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

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimi açıklar.

Örnek

// cliext_hash_multimap_generic_container.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multimap::generic_container^ gc1 = %c1;
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(Myhash_multimap::make_value(L'd', 4));
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(Myhash_multimap::make_value(L'e', 5));
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::generic_iterator

Kapsayıcının genel arabirimiyle kullanılacak bir yineleyicinin türü.

Sözdizimi

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

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılabilecek genel bir yineleyiciyi açıklar.

Örnek

// cliext_hash_multimap_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multimap::generic_container^ gc1 = %c1;
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multimap::generic_iterator gcit = gc1->begin();
    Myhash_multimap::generic_value gcval = *gcit;
    System::Console::Write("[{0} {1}] ", gcval->first, gcval->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::generic_reverse_iterator

Kapsayıcının genel arabirimiyle kullanılacak ters yineleyicinin türü.

Sözdizimi

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

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılabilecek genel bir ters yineleyiciyi açıklar.

Örnek

// cliext_hash_multimap_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multimap::generic_container^ gc1 = %c1;
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

hash_multimap::generic_value

Kapsayıcının genel arabirimiyle kullanılacak bir öğenin türü.

Sözdizimi

typedef GValue generic_value;

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılmak üzere depolanan öğe değerini açıklayan türdeki GValue bir nesneyi açıklar.

Örnek

// cliext_hash_multimap_generic_value.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multimap::generic_container^ gc1 = %c1;
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

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

hash_multimap::hash_delegate

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

Sözdizimi

hasher^ hash_delegate();

Açıklamalar

Üye işlevi, bir anahtar değerini tamsayıya dönüştürmek için kullanılan temsilciyi döndürür. Bir anahtarı karma olarak kullanmak için bunu kullanırsınız.

Örnek

// cliext_hash_multimap_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::hasher^ myhash = c1.hash_delegate();

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

hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_multimap::hash_multimap

Bir kapsayıcı nesnesi oluşturur.

Sözdizimi

hash_multimap();
explicit hash_multimap(key_compare^ pred);
hash_multimap(key_compare^ pred, hasher^ hashfn);
hash_multimap(hash_multimap<Key, Mapped>% right);
hash_multimap(hash_multimap<Key, Mapped>^ right);
template<typename InIter>
    hash_multimaphash_multimap(InIter first, InIter last);
template<typename InIter>
    hash_multimap(InIter first, InIter last,
        key_compare^ pred);
template<typename InIter>
    hash_multimap(InIter first, InIter last,
        key_compare^ pred, hasher^ hashfn);
hash_multimap(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_multimap(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);
hash_multimap(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred, hasher^ hashfn);

Parametreler

first
Eklenecek aralığın başlangıcı.

hashfn
Anahtarları demetlere eşlemek için karma işlevi.

last
Eklenecek aralık sonu.

pred
Denetlenen sıra için sıralama koşulu.

right
Eklenecek nesne veya aralık.

Açıklamalar

Oluşturucu:

hash_multimap();

, denetimli sırayı öğe olmadan, varsayılan sıralama koşuluyla key_compare()ve varsayılan karma işleviyle başlatır. Varsayılan sıralama koşulu ve karma işleviyle boş bir ilk denetimli dizi belirtmek için bunu kullanırsınız.

Oluşturucu:

explicit hash_multimap(key_compare^ pred);

, denetimli diziyi öğe olmadan, sıralama koşuluyla predve varsayılan karma işleviyle başlatır. Belirtilen sıralama koşulu ve varsayılan karma işleviyle boş bir ilk denetimli dizi belirtmek için bunu kullanırsınız.

Oluşturucu:

hash_multimap(key_compare^ pred, hasher^ hashfn);

denetimli diziyi öğe olmadan, sıralama koşuluyla predve karma işleviyle hashfnbaşlatır. Belirtilen sıralama koşulu ve karma işleviyle boş bir ilk denetimli dizi belirtmek için bunu kullanırsınız.

Oluşturucu:

hash_multimap(hash_multimap<Key, Mapped>% right);

denetimli sırayı [right.begin(), right.end()) dizisiyle, varsayılan sıralama koşuluyla ve varsayılan karma işleviyle başlatır. Varsayılan sıralama koşulu ve karma işleviyle, nesnesi righttarafından hash_multimap denetlenen dizinin bir kopyası olan ilk denetimli diziyi belirtmek için bunu kullanırsınız.

Oluşturucu:

hash_multimap(hash_multimap<Key, Mapped>^ right);

denetimli sırayı [right->begin(), right->end()) dizisiyle, varsayılan sıralama koşuluyla ve varsayılan karma işleviyle başlatır. Varsayılan sıralama koşulu ve karma işleviyle, nesnesi righttarafından hash_multimap denetlenen dizinin bir kopyası olan ilk denetimli diziyi belirtmek için bunu kullanırsınız.

Oluşturucu:

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

, denetimli sırayı [first, last), varsayılan sıralama koşuluyla ve varsayılan karma işleviyle dizisiyle başlatır. Denetimli sırayı, varsayılan sıralama koşulu ve karma işleviyle başka bir dizinin kopyası yapmak için kullanırsınız.

Oluşturucu:

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

, sıralama koşuluyla [first, last)predve varsayılan karma işleviyle dizisiyle denetimli diziyi başlatır. Belirtilen sıralama koşulu ve varsayılan karma işleviyle denetimli diziyi başka bir dizinin kopyası yapmak için kullanırsınız.

Oluşturucu:

template<typename InIter> hash_multimap(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

, sıralama [first, last)koşuluyla predve karma işleviyle hashfndizisiyle denetimli diziyi başlatır. Denetimli diziyi, belirtilen sıralama koşulu ve karma işleviyle başka bir dizinin kopyası yapmak için kullanırsınız.

Oluşturucu:

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

, varsayılan sıralama koşuluyla ve varsayılan karma işleviyle numaralandırıcı righttarafından belirlenen diziyle denetimli diziyi başlatır. Denetimli sırayı, varsayılan sıralama koşulu ve karma işleviyle bir numaralandırıcı tarafından açıklanan başka bir dizinin kopyası yapmak için kullanırsınız.

Oluşturucu:

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

, sıralama koşuluyla predve varsayılan karma işleviyle numaralandırıcı righttarafından belirlenen diziyle denetimli diziyi başlatır. Denetimli diziyi, belirtilen sıralama koşulu ve varsayılan karma işleviyle bir numaralandırıcı tarafından açıklanan başka bir dizinin kopyası yapmak için kullanırsınız.

Oluşturucu:

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

, sıralama koşuluyla predve karma işleviyle hashfnnumaralandırıcı righttarafından belirlenen diziyle denetimli diziyi başlatır. Denetimli diziyi, belirtilen sıralama koşulu ve karma işleviyle bir numaralandırıcı tarafından açıklanan başka bir dizinin kopyası yapmak için kullanırsınız.

Örnek

// cliext_hash_multimap_construct.cpp
// compile with: /clr
#include <cliext/hash_map>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

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

    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    c2.insert(c1.begin(), c1.end());
    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an ordering rule and hash function
    Myhash_multimap c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multimap::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

    c2h.insert(c1.begin(), c1.end());
    for each (Myhash_multimap::value_type elem in c2h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_multimap c3(c1.begin(), c1.end());
    for each (Myhash_multimap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

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

    // construct with an iterator range and an ordering rule and hash function
    Myhash_multimap c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multimap::hasher(&myfun));
    for each (Myhash_multimap::value_type elem in c4h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an enumeration
    Myhash_multimap c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_multimap::value_type>^)%c3);
    for each (Myhash_multimap::value_type elem in c5)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Myhash_multimap c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_multimap::value_type>^)%c3,
                cliext::greater_equal<wchar_t>());
    for each (Myhash_multimap::value_type elem in c6)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule and hash function
    Myhash_multimap c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_multimap::value_type>^)%c3,
                cliext::greater_equal<wchar_t>(),
                gcnew Myhash_multimap::hasher(&myfun));
    for each (Myhash_multimap::value_type elem in c6h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct by copying another container
    Myhash_multimap c7(c4);
    for each (Myhash_multimap::value_type elem in c7)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying a container handle
    Myhash_multimap c8(%c3);
    for each (Myhash_multimap::value_type elem in c8)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

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

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

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

hash_multimap::hasher

Anahtar için karma temsilcisi.

Sözdizimi

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

Açıklamalar

Türü, bir anahtar değerini tamsayıya dönüştüren bir temsilciyi açıklar.

Örnek

// cliext_hash_multimap_hasher.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::hasher^ myhash = c1.hash_delegate();

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

hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_multimap::insert

Öğeleri ekler.

Sözdizimi

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

Parametreler

first
Eklenecek aralığın başlangıcı.

last
Eklenecek aralık sonu.

right
Eklenecek numaralandırma.

val
Eklenecek anahtar değeri.

where
Eklenecek kapsayıcının neresinde (yalnızca ipucu).

Açıklamalar

Üye işlevlerin her biri, kalan işlenenler tarafından belirtilen bir dizi ekler.

İlk üye işlevi, değerine valsahip bir öğe ekler ve yeni eklenen öğeyi belirten bir yineleyici döndürür. Tek bir öğe eklemek için bunu kullanırsınız.

İkinci üye işlevi, ipucu olarak kullanarak where (performansı geliştirmek için) değerine valsahip bir öğe ekler ve yeni eklenen öğeyi belirten bir yineleyici döndürür. Bunu, bildiğiniz bir öğenin yanına olabilecek tek bir öğe eklemek için kullanırsınız.

Üçüncü üye işlevi dizisini [first, last)ekler. Başka bir diziden kopyalanan sıfır veya daha fazla öğe eklemek için bunu kullanırsınız.

Dördüncü üye işlevi tarafından belirlenen diziyi rightekler. Bunu bir numaralandırıcı tarafından açıklanan bir dizi eklemek için kullanırsınız.

Her öğe ekleme işlemi, denetlenen dizideki öğe sayısının logaritmasıyla orantılı olarak zaman alır. Ekleme işlemi amorti edilmiş sabit süre içinde gerçekleşebilir ancak ekleme noktasının yanında bir öğeyi belirten bir ipucu verilir.

Örnek

// cliext_hash_multimap_insert.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    Myhash_multimap::iterator it =
        c1.insert(Myhash_multimap::make_value(L'x', 24));
    System::Console::WriteLine("insert([L'x' 24]) = [{0} {1}]",
        it->first, it->second);

    it = c1.insert(Myhash_multimap::make_value(L'b', 2));
    System::Console::WriteLine("insert([L'b' 2]) = [{0} {1}]",
        it->first, it->second);

    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value with hint
    it = c1.insert(c1.begin(), Myhash_multimap::make_value(L'y', 25));
    System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
        it->first, it->second);
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_multimap c2;
    it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_multimap c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Myhash_multimap::value_type>^)%c1);
    for each (Myhash_multimap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
insert([L'x' 24]) = [x 24]
insert([L'b' 2]) = [b 2]
[a 1] [b 2] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [b 2] [c 3] [x 24]
[a 1] [b 2] [b 2] [c 3] [x 24] [y 25]

hash_multimap::iterator

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

Sözdizimi

typedef T1 iterator;

Açıklamalar

türü, denetlenen dizi için çift yönlü yineleyici görevi görecek belirtilmemiş türdeki T1 bir nesneyi açıklar.

Örnek

// cliext_hash_multimap_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("[{0} {1}] ", it->first, it->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::key_comp

İki anahtar için sıralama temsilcisini kopyalar.

Sözdizimi

key_compare^key_comp();

Açıklamalar

Üye işlevi, denetlenen sırayı sıralamak için kullanılan sıralama temsilcisini döndürür. bunu iki anahtarı karşılaştırmak için kullanırsınız.

Örnek

// cliext_hash_multimap_key_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::key_compare^ kcomp = c1.key_comp();

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

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

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

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

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

hash_multimap::key_compare

İki anahtar için sıralama temsilcisi.

Sözdizimi

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

Açıklamalar

türü, temsilcinin anahtar bağımsız değişkenlerinin sırasını belirleyen bir eş anlamlıdır.

Örnek

// cliext_hash_multimap_key_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::key_compare^ kcomp = c1.key_comp();

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

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

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

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

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

hash_multimap::key_type

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

Sözdizimi

typedef Key key_type;

Açıklamalar

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

Örnek

// cliext_hash_multimap_key_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using key_type
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_multimap::key_type val = it->first;

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

a b c

hash_multimap::load_factor

Demet başına ortalama öğeyi sayar.

Sözdizimi

float load_factor();

Açıklamalar

Üye işlevi döndürür (float)size() / bucket_count(). Ortalama demet boyutunu belirlemek için bunu kullanırsınız.

Örnek

// cliext_hash_multimap_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1 = gcnew Myhash_multimap;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_multimap::lower_bound

Belirtilen anahtarla eşleşen aralığın başlangıcını bulur.

Sözdizimi

iterator lower_bound(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

Üye işlevi, denetimli dizideki ile aynı demete key karma oluşturan ve ile eşdeğer sıralamaya sahip olan ilk öğeyi X keybelirler. Böyle bir öğe yoksa döndürür hash_multimap::end(); aksi takdirde öğesini belirten Xbir yineleyici döndürür. Bunu, şu anda belirli bir anahtarla eşleşen denetimli dizide bulunan bir öğe dizisinin başlangıcını bulmak için kullanırsınız.

Örnek

// cliext_hash_multimap_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    Myhash_multimap::iterator it = c1.lower_bound(L'a');
    System::Console::WriteLine("*lower_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.lower_bound(L'b');
    System::Console::WriteLine("*lower_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
lower_bound(L'x')==end() = True
*lower_bound(L'a') = [a 1]
*lower_bound(L'b') = [b 2]

hash_multimap::make_value

Bir değer nesnesi oluşturur.

Sözdizimi

static value_type make_value(key_type key, mapped_type mapped);

Parametreler

key
Kullanılacak anahtar değeri.

mapped
Aranacak eşlenmiş değer.

Açıklamalar

Üye işlevi, anahtarı key olan ve eşlenen değeri mappedolan bir value_type nesnesi döndürür. Bunu, diğer birkaç üye işleviyle kullanıma uygun bir nesne oluşturmak için kullanırsınız.

Örnek

// cliext_hash_multimap_make_value.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::mapped_type

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

Sözdizimi

typedef Mapped mapped_type;

Açıklamalar

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

Örnek

// cliext_hash_multimap_mapped_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using mapped_type
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in mapped_type object
        Myhash_multimap::mapped_type val = it->second;

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

1 2 3

hash_multimap::max_load_factor

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

Sözdizimi

float max_load_factor();
void max_load_factor(float new_factor);

Parametreler

new_factor
Depolamak için yeni maksimum yük faktörü.

Açıklamalar

İlk üye işlevi, depolanan geçerli en yüksek yük faktörünü döndürür. Maksimum ortalama demet boyutunu belirlemek için bunu kullanırsınız.

İkinci üye işlevi deponun en büyük yük faktörünü ile new_factordeğiştirir. Sonraki eklemeye kadar otomatik yeniden düzenleme gerçekleşmez.

Örnek

// cliext_hash_multimap_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1 = gcnew Myhash_multimap;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_multimap::operator=

Denetimli sıranın yerini alır.

Sözdizimi

hash_multimap<Key, Mapped>% operator=(hash_multimap<Key, Mapped>% right);

Parametreler

right
Kopyalanacak kapsayıcı.

Açıklamalar

Üye işleci nesnesine kopyalanır right ve döndürür *this. Denetimli sırayı içindeki rightdenetimli sıranın bir kopyasıyla değiştirmek için kullanırsınız.

Örnek

// cliext_hash_multimap_operator_as.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_multimap c2;
    c2 = c1;
// display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::rbegin

Ters denetimli sıranın başlangıcını belirtir.

Sözdizimi

reverse_iterator rbegin();

Açıklamalar

Üye işlevi, denetlenen dizinin son öğesini veya boş bir dizinin başlangıcının hemen ötesinde belirten bir ters yineleyici döndürür. Bu nedenle, ters sıranın öğesini belirtir beginning . Ters sırada görülen denetimli sıranın current başlangıcını belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_hash_multimap_rbegin.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_multimap::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*++rbegin() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*rbegin() = [c 3]
*++rbegin() = [b 2]

hash_multimap::reference

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

Sözdizimi

typedef value_type% reference;

Açıklamalar

türü, bir öğeye başvuruyu açıklar.

Örnek

// cliext_hash_multimap_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_multimap::reference ref = *it;
        System::Console::Write("[{0} {1}] ", ref->first, ref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::rehash

Karma tabloyu yeniden oluşturur.

Sözdizimi

void rehash();

Açıklamalar

Üye işlevi karma tabloyu yeniden oluşturur ve bunu sağlar load_factor() <= max_load_factor(). Aksi takdirde, karma tablosunun boyutu yalnızca eklemeden sonra gerektiği gibi artar. (Boyutu hiçbir zaman otomatik olarak azalmaz.) Karma tablosunun boyutunu ayarlamak için bunu kullanırsınız.

Örnek

// cliext_hash_multimap_rehash.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1 = gcnew Myhash_multimap;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_multimap::rend

Ters denetimli sıranın sonunu belirtir.

Sözdizimi

reverse_iterator rend();

Açıklamalar

Üye işlevi, denetlenen sıranın başlangıcının hemen ötesine işaret eden bir ters yineleyici döndürür. Bu nedenle, ters sıranın öğesini belirtir end . Ters sırada görülen denetimli sıranın current sonunu belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_hash_multimap_rend.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_multimap::reverse_iterator rit = c1.rend();
    --rit;
    --rit;
    System::Console::WriteLine("*-- --rend() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*--rend() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*-- --rend() = [b 2]
*--rend() = [a 1]

hash_multimap::reverse_iterator

Denetimli sıra için ters yineleyicinin türü.

Sözdizimi

typedef T3 reverse_iterator;

Açıklamalar

türü, denetlenen dizi için ters yineleyici görevi görecek belirtilmemiş türdeki T3 bir nesneyi açıklar.

Örnek

// cliext_hash_multimap_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_multimap::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("[{0} {1}] ", rit->first, rit->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::size

Öğe sayısını sayar.

Sözdizimi

size_type size();

Açıklamalar

Üye işlevi, denetlenen sıranın uzunluğunu döndürür. Şu anda denetimli dizideki öğelerin sayısını belirlemek için bunu kullanırsınız. Tek ilgilendiğiniz dizinin sıfır olmayan boyuta sahip olup olmadığıysa, bkz hash_multimap::empty(). .

Örnek

// cliext_hash_multimap_size.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(Myhash_multimap::make_value(L'd', 4));
    c1.insert(Myhash_multimap::make_value(L'e', 5));
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0 after clearing
size() = 2 after adding 2

hash_multimap::size_type

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

Sözdizimi

typedef int size_type;

Açıklamalar

Türü negatif olmayan öğe sayısını açıklar.

Örnek

// cliext_hash_multimap_size_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_multimap::size_type diff = 0;
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

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

hash_multimap::swap

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

Sözdizimi

void swap(hash_multimap<Key, Mapped>% right);

Parametreler

right
İçindekileri değiştirecek kapsayıcı.

Açıklamalar

Üye işlevi, ve arasında this rightdenetlenen dizileri değiştirir. Bunu sürekli olarak yapar ve hiçbir özel durum oluşturmaz. bunu, iki kapsayıcının içeriğini değiştirmek için hızlı bir yol olarak kullanırsınız.

Örnek

// cliext_hash_multimap_swap.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_multimap c2;
    c2.insert(Myhash_multimap::make_value(L'd', 4));
    c2.insert(Myhash_multimap::make_value(L'e', 5));
    c2.insert(Myhash_multimap::make_value(L'f', 6));
    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::to_array

Denetimli diziyi yeni bir diziye kopyalar.

Sözdizimi

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

Açıklamalar

üye işlevi, denetlenen diziyi içeren bir dizi döndürür. Denetimli sıranın bir kopyasını dizi biçiminde almak için bunu kullanırsınız.

Örnek

// cliext_hash_multimap_to_array.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

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

    c1.insert(Myhash_multimap::make_value(L'd', 4));
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (Myhash_multimap::value_type elem in a1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

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

hash_multimap::upper_bound

Belirtilen anahtarla eşleşen aralığın sonunu bulur.

Sözdizimi

iterator upper_bound(key_type key);

Parametreler

key
Aranacak anahtar değeri.

Açıklamalar

Üye işlevi, denetimli dizideki ile aynı demete key karma oluşturan ve ile eşdeğer sıralamaya sahip olan son öğeyi X keybelirler. Böyle bir öğe yoksa veya denetlenen dizideki son öğeyse X döndürür hash_multimap::end(); aksi takdirde, öğesinin ötesindeki Xilk öğeyi belirten bir yineleyici döndürür. Bunu, şu anda denetimli dizide belirtilen bir anahtarla eşleşen bir öğe dizisinin sonunu bulmak için kullanırsınız.

Örnek

// cliext_hash_multimap_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    Myhash_multimap::iterator it = c1.upper_bound(L'a');
    System::Console::WriteLine("*upper_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.upper_bound(L'b');
    System::Console::WriteLine("*upper_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
upper_bound(L'x')==end() = True
*upper_bound(L'a') = [b 2]
*upper_bound(L'b') = [c 3]

hash_multimap::value_comp

İki öğe değeri için sıralama temsilcisini kopyalar.

Sözdizimi

value_compare^ value_comp();

Açıklamalar

Üye işlevi, denetlenen sırayı sıralamak için kullanılan sıralama temsilcisini döndürür. bunu iki öğe değerini karşılaştırmak için kullanırsınız.

Örnek

// cliext_hash_multimap_value_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_multimap::make_value(L'a', 1),
            Myhash_multimap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_multimap::make_value(L'a', 1),
            Myhash_multimap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_multimap::make_value(L'b', 2),
            Myhash_multimap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

hash_multimap::value_compare

İki öğe değeri için sıralama temsilcisi.

Sözdizimi

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

Açıklamalar

türü, temsilcinin değer bağımsız değişkenlerinin sırasını belirleyen bir eş anlamlıdır.

Örnek

// cliext_hash_multimap_value_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_multimap::make_value(L'a', 1),
            Myhash_multimap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_multimap::make_value(L'a', 1),
            Myhash_multimap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_multimap::make_value(L'b', 2),
            Myhash_multimap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

hash_multimap::value_type

Öğenin türü.

Sözdizimi

typedef generic_value value_type;

Açıklamalar

türü, için generic_valuebir eş anlamlıdır.

Örnek

// cliext_hash_multimap_value_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using value_type
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_multimap::value_type val = *it;
        System::Console::Write("[{0} {1}] ", val->first, val->second);
        }
    System::Console::WriteLine();
    return (0);
    }

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