hash_map (STL/CLR)

Kelas templat menjelaskan objek yang mengontrol urutan elemen dengan panjang yang bervariasi yang memiliki akses dua arah. Anda menggunakan kontainer hash_map untuk mengelola urutan elemen sebagai tabel hash, setiap entri tabel menyimpan daftar node yang ditautkan dua arah, dan setiap simpul menyimpan satu elemen. Elemen terdiri dari kunci, untuk memesan urutan, dan nilai yang dipetakan, yang berjalan bersama untuk perjalanan.

Dalam deskripsi di bawah ini, GValue sama dengan:

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

di mana:

GKey sama seperti Key kecuali yang terakhir adalah jenis ref, dalam hal ini Key^

GMapped sama seperti Mapped kecuali yang terakhir adalah jenis ref, dalam hal ini Mapped^

Sintaks

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

Parameter

Key
Jenis komponen kunci elemen dalam urutan terkontrol.

Mapped
Jenis komponen lain dari elemen dalam urutan terkontrol.

Persyaratan

Header:<cliext/hash_map>

kumpulan nama XML: cliext

Deklarasi

Definisi jenis	Deskripsi
hash_map::const_iterator	Jenis iterator konstan untuk urutan terkontrol.
hash_map::const_reference	Jenis referensi konstanta ke elemen.
hash_map::const_reverse_iterator	Jenis iterator terbalik konstan untuk urutan terkontrol.
hash_map::difference_type	Jenis jarak (mungkin ditandatangani) antara dua elemen.
hash_map::generic_container	Jenis antarmuka generik untuk kontainer.
hash_map::generic_iterator	Jenis iterator untuk antarmuka generik untuk kontainer.
hash_map::generic_reverse_iterator	Jenis iterator terbalik untuk antarmuka generik untuk kontainer.
hash_map::generic_value	Jenis elemen untuk antarmuka generik untuk kontainer.
hash_map::hasher	Delegasi hash untuk kunci.
hash_map::iterator	Jenis iterator untuk urutan yang dikontrol.
hash_map::key_compare	Delegasi pemesanan untuk dua kunci.
hash_map::key_type	Jenis kunci pemesanan.
hash_map::mapped_type	Jenis nilai yang dipetakan yang terkait dengan setiap kunci.
hash_map::reference	Jenis referensi ke elemen.
hash_map::reverse_iterator	Jenis iterator terbalik untuk urutan yang dikontrol.
hash_map::size_type	Jenis jarak (non-negatif) antara dua elemen.
hash_map::value_compare	Delegasi pengurutan untuk dua nilai elemen.
hash_map::value_type	Jenis elemen.

Fungsi anggota	Deskripsi
hash_map::begin	Menunjuk awal urutan yang dikontrol.
hash_map::bucket_count	Menghitung jumlah wadah.
hash_map::clear	Menghapus semua elemen.
hash_map::count	Menghitung elemen yang cocok dengan kunci tertentu.
hash_map::empty	Menguji apakah tidak ada elemen yang ada.
hash_map::end	Menunjuk akhir urutan yang dikontrol.
hash_map::equal_range	Menemukan rentang yang cocok dengan kunci tertentu.
hash_map::erase	Menghapus elemen pada posisi yang ditentukan.
hash_map::find	Menemukan elemen yang cocok dengan kunci tertentu.
hash_map::hash_delegate	Menyalin delegasi hashing untuk kunci.
hash_map::hash_map	Membuat objek kontainer.
hash_map::insert	Menambahkan elemen.
hash_map::key_comp	Menyalin delegasi pengurutan untuk dua kunci.
hash_map::load_factor	Menghitung elemen rata-rata per wadah.
hash_map::lower_bound	Menemukan awal rentang yang cocok dengan kunci tertentu.
hash_map::make_value	Membuat objek nilai.
hash_map::max_load_factor	Mendapatkan atau mengatur elemen maksimum per wadah.
hash_map::rbegin	Menunjuk awal urutan terkontrol terbalik.
hash_map::rehash	Membangun kembali tabel hash.
hash_map::rend	Menunjuk akhir urutan terkontrol terbalik.
hash_map::size	Menghitung jumlah elemen.
hash_map::swap	Menukar isi dua kontainer.
hash_map::to_array	Menyalin urutan terkontrol ke array baru.
hash_map::upper_bound	Menemukan akhir rentang yang cocok dengan kunci tertentu.
hash_map::value_comp	Menyalin delegasi pengurutan untuk dua nilai elemen.

Operator	Deskripsi
hash_map::operator=	Menggantikan urutan terkontrol.
hash_map::operator[]	Memetakan kunci ke nilai yang dipetakan terkait.

Antarmuka

Antarmuka	Deskripsi
ICloneable	Menduplikasi objek.
IEnumerable	Urutan melalui elemen.
ICollection	Pertahankan grup elemen.
IEnumerable<T>	Urutan melalui elemen yang ditik.
ICollection<T>	Pertahankan grup elemen yang diketik.
IDictionary<TKey,TValue>	Pertahankan grup pasangan {key, value}.
IHash<Key, Value>	Pertahankan kontainer generik.

Keterangan

Objek mengalokasikan dan membebaskan penyimpanan untuk urutan yang dikontrolnya sebagai simpul individual dalam daftar tertaut dua arah. Untuk mempercepat akses, objek juga mempertahankan array pointer dengan panjang yang bervariasi ke dalam daftar (tabel hash), secara efektif mengelola seluruh daftar sebagai urutan sublist, atau wadah. Ini menyisipkan elemen ke dalam wadah yang terus diurutkan dengan mengubah tautan antar simpul, tidak pernah dengan menyalin konten satu simpul ke simpul lain. Itu berarti Anda dapat menyisipkan dan menghapus elemen dengan bebas tanpa mengganggu elemen yang tersisa.

Objek memesan setiap wadah yang dikontrolnya dengan memanggil objek delegasi tersimpan jenis hash_set::key_compare. Anda dapat menentukan objek delegasi tersimpan saat membuat hash_set; jika Anda tidak menentukan objek delegasi, defaultnya adalah perbandingan operator<=(key_type, key_type).

Anda mengakses objek delegasi tersimpan dengan memanggil fungsi hash_set::key_comp()anggota . Objek delegasi semacam itu harus menentukan pengurutan yang setara antara kunci jenis hash_set::key_type. Itu berarti, untuk dua kunci X dan Y:

key_comp()(X, Y) mengembalikan hasil Boolean yang sama pada setiap panggilan.

Jika key_comp()(X, Y) && key_comp()(Y, X) benar, maka X dan Y dikatakan memiliki urutan yang setara.

Aturan pengurutan apa pun yang bertingkah seperti operator<=(key_type, key_type), operator>=(key_type, key_type) atau operator==(key_type, key_type) mendefinisikan pengurutan yang setara.

Kontainer hanya memastikan bahwa elemen yang kuncinya memiliki pengurutan yang setara (dan hash mana dengan nilai bilangan bulat yang sama) yang berdekatan dalam wadah. Tidak seperti kelas hash_multimaptemplat , objek kelas hash_map templat memastikan bahwa kunci untuk semua elemen unik. (Tidak ada dua kunci yang memiliki urutan yang setara.)

Objek menentukan wadah mana yang harus berisi kunci pengurutan tertentu dengan memanggil objek delegasi tersimpan dari jenis hash_set::hasher. Anda mengakses objek tersimpan ini dengan memanggil fungsi hash_set::hash_delegate anggota untuk mendapatkan nilai bilangan bulat yang bergantung pada nilai kunci. Anda dapat menentukan objek delegasi tersimpan saat membuat hash_set; jika Anda tidak menentukan objek delegasi, defaultnya adalah fungsi System::Object::hash_value(key_type). Itu berarti, untuk kunci X apa pun dan Y:

hash_delegate()(X) mengembalikan hasil bilangan bulat yang sama pada setiap panggilan.

Jika X dan Y memiliki pengurutan yang setara, maka hash_delegate()(X) harus mengembalikan hasil bilangan bulat yang sama dengan hash_delegate()(Y).

Setiap elemen berisi kunci terpisah dan nilai yang dipetakan. Urutan diwakili dengan cara yang mengizinkan pencarian, penyisipan, dan penghapusan elemen arbitrer dalam waktu konstan. Artinya, jumlah operasi tidak tergantung pada jumlah elemen dalam urutan, setidaknya dalam kasus terbaik. Selain itu, memasukkan elemen tidak membatalkan iterator, dan menghapus elemen hanya membatalkan iterator yang menunjuk pada elemen yang dihapus.

Namun, jika nilai hash tidak didistribusikan secara seragam, tabel hash dapat berdegenerasi. Secara ekstrem (untuk fungsi hash yang selalu mengembalikan nilai yang sama), pencarian, penyisipan, dan penghapusan sebanding dengan jumlah elemen dalam urutan (waktu linier). Kontainer berusaha untuk memilih fungsi hash yang wajar, ukuran bucket rata-rata, dan ukuran hash-table (jumlah total wadah), tetapi Anda dapat mengambil alih salah satu atau semua pilihan ini. Lihat, misalnya, fungsi hash_set::max_load_factor dan hash_set::rehash.

Mendukung hash_map iterator dua arah, yang berarti Anda dapat melangkah ke elemen yang berdekatan mengingat iterator yang menunjuk elemen dalam urutan terkontrol. Simpul kepala khusus sesuai dengan iterator yang dikembalikan oleh end(). Anda dapat mengurangi iterator ini untuk mencapai elemen terakhir dalam urutan terkontrol, jika ada. Anda dapat menaikkan hash_map iterator untuk mencapai simpul kepala, dan kemudian akan dibandingkan dengan end(). Tetapi Anda tidak dapat mendereferensikan iterator yang dikembalikan oleh end().

Anda tidak dapat merujuk ke elemen yang hash_map secara langsung mengingat posisi numeriknya; yang memerlukan iterator akses acak.

Iterator hash_map menyimpan handel ke simpul terkait hash_map , yang pada gilirannya menyimpan handel ke kontainer terkait. Anda hanya dapat menggunakan iterator dengan objek kontainer terkait. Iterator hash_map tetap valid selama simpul terkait hash_map dikaitkan dengan beberapa hash_map. Selain itu, iterator yang valid dapat didereferensikan. Anda dapat menggunakannya untuk mengakses atau mengubah nilai elemen yang ditunjuknya, selama tidak sama dengan end().

Menghapus atau menghapus elemen memanggil destruktor untuk nilai tersimpannya. Menghancurkan kontainer akan menghapus semua elemen. Dengan demikian, kontainer yang jenis elemennya adalah kelas ref memastikan bahwa tidak ada elemen yang lebih lama dari kontainer. Namun, perhatikan bahwa kontainer handel tidak* menghancurkan elemennya.

Anggota

hash_map::begin

Menunjuk awal urutan yang dikontrol.

Sintaks

iterator begin();

Keterangan

Fungsi anggota mengembalikan iterator dua arah yang menunjuk elemen pertama dari urutan yang dikontrol, atau tepat di luar akhir urutan kosong. Anda menggunakannya untuk mendapatkan iterator yang menunjuk current awal urutan terkontrol, tetapi statusnya dapat berubah jika panjang urutan terkontrol berubah.

Contoh

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

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

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

    // inspect first two items
    Myhash_map::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_map::bucket_count

Menghitung jumlah wadah.

Sintaks

int bucket_count();

Keterangan

Fungsi anggota mengembalikan jumlah wadah saat ini. Anda menggunakannya untuk menentukan ukuran tabel hash.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::clear

Menghapus semua elemen.

Sintaks

void clear();

Keterangan

Fungsi anggota secara efektif memanggil erase(begin(), end()). Anda menggunakannya untuk memastikan bahwa urutan yang dikontrol kosong.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::make_value(L'a', 1));
    c1.insert(Myhash_map::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Myhash_map::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_map::const_iterator

Jenis iterator konstan untuk urutan terkontrol.

Sintaks

typedef T2 const_iterator;

Keterangan

Jenis ini menjelaskan objek jenis yang tidak ditentukan T2 yang dapat berfungsi sebagai iterator dua arah konstan untuk urutan yang dikontrol.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::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_map::const_reference

Jenis referensi konstanta ke elemen.

Sintaks

typedef value_type% const_reference;

Keterangan

Jenis ini menjelaskan referensi konstan ke elemen.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_map::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_map::const_reverse_iterator

Jenis iterator terbalik konstan untuk urutan terkontrol.

Sintaks

typedef T4 const_reverse_iterator;

Keterangan

Jenis menjelaskan objek jenis yang tidak ditentukan T4 yang dapat berfungsi sebagai iterator terbalik konstan untuk urutan yang dikontrol.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_map::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_map::count

Menemukan jumlah elemen yang cocok dengan kunci tertentu.

Sintaks

size_type count(key_type key);

Parameter

key
Nilai kunci yang akan dicari.

Keterangan

Fungsi anggota mengembalikan jumlah elemen dalam urutan terkontrol yang memiliki pengurutan yang setara dengan key. Anda menggunakannya untuk menentukan jumlah elemen yang saat ini berada dalam urutan terkontrol yang cocok dengan kunci yang ditentukan.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::difference_type

Jenis jarak yang ditandatangani antara dua elemen.

Sintaks

typedef int difference_type;

Keterangan

Jenis ini menjelaskan jumlah elemen yang mungkin negatif.

Contoh

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

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

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

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

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

Menguji apakah tidak ada elemen yang ada.

Sintaks

bool empty();

Keterangan

Fungsi anggota mengembalikan true urutan yang dikontrol kosong. Ini setara dengan size() == 0. Anda menggunakannya untuk menguji apakah hash_map kosong.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::end

Menunjuk akhir urutan yang dikontrol.

Sintaks

iterator end();

Keterangan

Fungsi anggota mengembalikan iterator dua arah yang menunjuk tepat di luar akhir urutan yang dikontrol. Anda menggunakannya untuk mendapatkan iterator yang menunjuk akhir urutan yang dikontrol; statusnya tidak berubah jika panjang urutan terkontrol berubah.

Contoh

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

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

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

    // inspect last two items
    Myhash_map::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_map::equal_range

Menemukan rentang yang cocok dengan kunci tertentu.

Sintaks

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

Parameter

key
Nilai kunci yang akan dicari.

Keterangan

Fungsi anggota mengembalikan sepasang iterator cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Anda menggunakannya untuk menentukan rentang elemen yang saat ini berada dalam urutan terkontrol yang cocok dengan kunci yang ditentukan.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::erase

Menghapus elemen pada posisi yang ditentukan.

Sintaks

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

Parameter

first
Awal rentang untuk menghapus.

key
Nilai kunci untuk menghapus.

last
Akhir rentang untuk menghapus.

where
Elemen untuk menghapus.

Keterangan

Fungsi anggota pertama menghapus elemen urutan terkontrol yang diarahkan oleh where, dan mengembalikan iterator yang menunjuk elemen pertama yang tersisa di luar elemen yang dihapus, atau end() jika tidak ada elemen tersebut. Anda menggunakannya untuk menghapus satu elemen.

Fungsi anggota kedua menghapus elemen urutan terkontrol dalam rentang [first, last), dan mengembalikan iterator yang menunjuk elemen pertama yang tersisa di luar elemen apa pun yang dihapus, atau end() jika tidak ada elemen tersebut. Anda menggunakannya untuk menghapus nol atau lebih elemen yang berdada.

Fungsi anggota ketiga menghapus elemen apa pun dari urutan terkontrol yang kuncinya memiliki urutan yang setara dengan key, dan mengembalikan hitungan jumlah elemen yang dihapus. Anda menggunakannya untuk menghapus dan menghitung semua elemen yang cocok dengan kunci tertentu.

Setiap penghapusan elemen membutuhkan waktu yang sebanding dengan logaritma jumlah elemen dalam urutan yang dikontrol.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::hash_map<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_map<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_map<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::hash_map<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::hash_map<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_map::find

Menemukan elemen yang cocok dengan kunci tertentu.

Sintaks

iterator find(key_type key);

Parameter

key
Nilai kunci yang akan dicari.

Keterangan

Jika setidaknya satu elemen dalam urutan terkontrol memiliki urutan yang setara dengan key, fungsi anggota mengembalikan iterator yang menunjuk salah satu elemen tersebut; jika tidak, ia mengembalikan end(). Anda menggunakannya untuk menemukan elemen yang saat ini berada dalam urutan terkontrol yang cocok dengan kunci yang ditentukan.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::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_map::generic_container

Jenis antarmuka generik untuk kontainer.

Sintaks

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

Keterangan

Jenis menjelaskan antarmuka generik untuk kelas kontainer templat ini.

Contoh

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

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

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

    // construct a generic container
    Myhash_map::generic_container^ gc1 = %c1;
    for each (Myhash_map::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_map::make_value(L'd', 4));
    for each (Myhash_map::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_map::make_value(L'e', 5));
    for each (Myhash_map::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_map::generic_iterator

Jenis iterator untuk digunakan dengan antarmuka generik untuk kontainer.

Sintaks

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

Keterangan

Jenis ini menjelaskan iterator generik yang dapat digunakan dengan antarmuka generik untuk kelas kontainer templat ini.

Contoh

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

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

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

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

    // get an element and display it
    Myhash_map::generic_iterator gcit = gc1->begin();
    Myhash_map::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_map::generic_reverse_iterator

Jenis iterator terbalik untuk digunakan dengan antarmuka generik untuk kontainer.

Sintaks

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

Keterangan

Jenis ini menjelaskan iterator terbalik generik yang dapat digunakan dengan antarmuka generik untuk kelas kontainer templat ini.

Contoh

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

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

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

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

    // get an element and display it
    Myhash_map::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_map::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_map::generic_value

Jenis elemen untuk digunakan dengan antarmuka generik untuk kontainer.

Sintaks

typedef GValue generic_value;

Keterangan

Jenis menjelaskan objek jenis GValue yang menjelaskan nilai elemen tersimpan untuk digunakan dengan antarmuka generik untuk kelas kontainer templat ini.

Contoh

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

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

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

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

    // get an element and display it
    Myhash_map::generic_iterator gcit = gc1->begin();
    Myhash_map::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_map::hash_delegate

Menemukan elemen yang cocok dengan kunci tertentu.

Sintaks

hasher^ hash_delegate();

Keterangan

Fungsi anggota mengembalikan delegasi yang digunakan untuk mengonversi nilai kunci menjadi bilangan bulat. Anda menggunakannya untuk hash kunci.

Contoh

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

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::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_map::hash_map

Membuat objek kontainer.

Sintaks

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

Parameter

first
Awal rentang yang akan disisipkan.

hashfn
Fungsi hash untuk memetakan kunci ke wadah.

last
Akhir rentang untuk disisipkan.

pred
Memesan predikat untuk urutan yang dikendalikan.

right
Objek atau rentang untuk disisipkan.

Keterangan

Konstruktor:

hash_map();

menginisialisasi urutan terkontrol tanpa elemen, dengan predikat key_compare()pengurutan default , dan dengan fungsi hash default. Anda menggunakannya untuk menentukan urutan awal yang dikontrol kosong, dengan predikat pengurutan default dan fungsi hash.

Konstruktor:

explicit hash_map(key_compare^ pred);

menginisialisasi urutan terkontrol tanpa elemen, dengan predikat predpengurutan , dan dengan fungsi hash default. Anda menggunakannya untuk menentukan urutan awal yang dikontrol kosong, dengan predikat pengurutan yang ditentukan dan fungsi hash default.

Konstruktor:

hash_map(key_compare^ pred, hasher^ hashfn);

menginisialisasi urutan terkontrol tanpa elemen, dengan predikat predpengurutan , dan dengan fungsi hashfnhash . Anda menggunakannya untuk menentukan urutan awal yang dikontrol kosong, dengan predikat pengurutan dan fungsi hash yang ditentukan.

Konstruktor:

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

menginisialisasi urutan terkontrol dengan urutan [right.begin(), right.end()), dengan predikat pengurutan default, dan dengan fungsi hash default. Anda menggunakannya untuk menentukan urutan terkontrol awal yang merupakan salinan urutan yang dikontrol hash_map oleh objek right, dengan predikat pengurutan default dan fungsi hash.

Konstruktor:

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

menginisialisasi urutan terkontrol dengan urutan [right->begin(), right->end()), dengan predikat pengurutan default, dan dengan fungsi hash default. Anda menggunakannya untuk menentukan urutan terkontrol awal yang merupakan salinan urutan yang dikontrol hash_map oleh objek right, dengan predikat pengurutan default dan fungsi hash.

Konstruktor:

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

menginisialisasi urutan terkontrol dengan urutan [first, last), dengan predikat pengurutan default, dan dengan fungsi hash default. Anda menggunakannya untuk membuat urutan terkontrol sebagai salinan urutan lain, dengan predikat pengurutan default dan fungsi hash.

Konstruktor:

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

menginisialisasi urutan terkontrol dengan urutan [first, last), dengan predikat predpengurutan , dan dengan fungsi hash default. Anda menggunakannya untuk membuat urutan terkontrol sebagai salinan urutan lain, dengan predikat pengurutan yang ditentukan dan fungsi hash default.

Konstruktor:

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

menginisialisasi urutan terkontrol dengan urutan [first, last), dengan predikat predpengurutan , dan dengan fungsi hashfnhash . Anda menggunakannya untuk membuat urutan terkontrol sebagai salinan urutan lain, dengan predikat urutan dan fungsi hash yang ditentukan.

Konstruktor:

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

menginisialisasi urutan terkontrol dengan urutan yang ditunjuk oleh enumerator right, dengan predikat pengurutan default, dan dengan fungsi hash default. Anda menggunakannya untuk membuat urutan terkontrol sebagai salinan urutan lain yang dijelaskan oleh enumerator, dengan predikat pengurutan default dan fungsi hash.

Konstruktor:

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

menginisialisasi urutan terkontrol dengan urutan yang ditunjuk oleh enumerator right, dengan predikat predpengurutan , dan dengan fungsi hash default. Anda menggunakannya untuk membuat urutan terkontrol salinan urutan lain yang dijelaskan oleh enumerator, dengan predikat pengurutan yang ditentukan dan fungsi hash default.

Konstruktor:

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

menginisialisasi urutan terkontrol dengan urutan yang ditunjuk oleh enumerator right, dengan predikat predpengurutan , dan dengan fungsi hashfnhash . Anda menggunakannya untuk membuat urutan terkontrol salinan urutan lain yang dijelaskan oleh enumerator, dengan predikat pengurutan dan fungsi hash yang ditentukan.

Contoh

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

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

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

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

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

    c2.insert(c1.begin(), c1.end());
    for each (Myhash_map::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_map c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_map::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

    c2h.insert(c1.begin(), c1.end());
    for each (Myhash_map::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_map c3(c1.begin(), c1.end());
    for each (Myhash_map::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_map c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (Myhash_map::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_map c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_map::hasher(&myfun));
    for each (Myhash_map::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_map c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_map::value_type>^)%c3);
    for each (Myhash_map::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_map c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_map::value_type>^)%c3,
                cliext::greater_equal<wchar_t>());
    for each (Myhash_map::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_map c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_map::value_type>^)%c3,
                cliext::greater_equal<wchar_t>(),
                gcnew Myhash_map::hasher(&myfun));
    for each (Myhash_map::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_map c7(c4);
    for each (Myhash_map::value_type elem in c7)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying a container handle
    Myhash_map c8(%c3);
    for each (Myhash_map::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_map::hasher

Delegasi hash untuk kunci.

Sintaks

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

Keterangan

Jenis menjelaskan delegasi yang mengonversi nilai kunci menjadi bilangan bulat.

Contoh

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

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::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_map::insert

Menambahkan elemen.

Sintaks

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

Parameter

first
Awal rentang yang akan disisipkan.

last
Akhir rentang untuk disisipkan.

right
Enumerasi untuk disisipkan.

val
Nilai kunci untuk disisipkan.

where
Di mana dalam kontainer untuk disisipkan (petunjuk saja).

Keterangan

Setiap fungsi anggota menyisipkan urutan yang ditentukan oleh operand yang tersisa.

Fungsi anggota pertama berupaya menyisipkan elemen dengan nilai val, dan mengembalikan sepasang nilai X. Jika X.second benar, X.first menunjuk elemen yang baru disisipkan; jika tidak X.first menunjuk elemen dengan pengurutan yang setara yang sudah ada dan tidak ada elemen baru yang dimasukkan. Anda menggunakannya untuk menyisipkan satu elemen.

Fungsi anggota kedua menyisipkan elemen dengan nilai val, menggunakan where sebagai petunjuk (untuk meningkatkan performa), dan mengembalikan iterator yang menunjuk elemen yang baru dimasukkan. Anda menggunakannya untuk menyisipkan satu elemen yang mungkin berada di samping elemen yang Anda ketahui.

Fungsi anggota ketiga menyisipkan urutan [first, last). Anda menggunakannya untuk menyisipkan nol atau lebih elemen yang disalin dari urutan lain.

Fungsi anggota keempat menyisipkan urutan yang ditunjuk oleh right. Anda menggunakannya untuk menyisipkan urutan yang dijelaskan oleh enumerator.

Setiap penyisipan elemen membutuhkan waktu sebanding dengan logaritma jumlah elemen dalam urutan yang dikontrol. Penyisipan dapat terjadi dalam waktu konstanta yang diamortisasi, namun, mengingat petunjuk yang menunjuk elemen di samping titik penyisipan.

Contoh

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

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

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

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

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

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

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

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

    // insert an enumeration
    Myhash_map c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Myhash_map::value_type>^)%c1);
    for each (Myhash_map::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] True
insert([L'b' 2]) = [b 2] False
[a 1] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [c 3] [x 24]
[a 1] [b 2] [c 3] [x 24] [y 25]

hash_map::iterator

Jenis iterator untuk urutan yang dikontrol.

Sintaks

typedef T1 iterator;

Keterangan

Jenis ini menjelaskan objek jenis yang tidak ditentukan T1 yang dapat berfungsi sebagai iterator dua arah untuk urutan terkontrol.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_map::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_map::key_comp

Menyalin delegasi pengurutan untuk dua kunci.

Sintaks

key_compare^key_comp();

Keterangan

Fungsi anggota mengembalikan delegasi pengurutan yang digunakan untuk mengurutkan urutan yang dikontrol. Anda menggunakannya untuk membandingkan dua kunci.

Contoh

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

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::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_map 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_map::key_compare

Delegasi pemesanan untuk dua kunci.

Sintaks

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

Keterangan

Jenis adalah sinonim untuk delegasi yang menentukan pengurutan argumen kuncinya.

Contoh

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

typedef cliext::hash_map<wchar_t, int> Myhash_map;
int main()
    {
    Myhash_map c1;
    Myhash_map::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_map 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_map::key_type

Jenis kunci pemesanan.

Sintaks

typedef Key key_type;

Keterangan

Jenisnya adalah sinonim untuk parameter Keytemplat .

Contoh

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

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

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

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

a b c

hash_map::load_factor

Menghitung elemen rata-rata per wadah.

Sintaks

float load_factor();

Keterangan

Fungsi anggota mengembalikan (float)size() / bucket_count(). Anda menggunakannya untuk menentukan ukuran wadah rata-rata.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::lower_bound

Menemukan awal rentang yang cocok dengan kunci tertentu.

Sintaks

iterator lower_bound(key_type key);

Parameter

key
Nilai kunci yang akan dicari.

Keterangan

Fungsi anggota menentukan elemen X pertama dalam urutan terkontrol yang hash ke wadah yang sama dengan key dan memiliki urutan yang setara dengan key. Jika tidak ada elemen seperti itu, elemen tersebut mengembalikan end(); jika tidak, elemen tersebut mengembalikan iterator yang menunjuk X. Anda menggunakannya untuk menemukan awal urutan elemen yang saat ini dalam urutan terkontrol yang cocok dengan kunci yang ditentukan.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::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_map::make_value

Membuat objek nilai.

Sintaks

static value_type make_value(key_type key, mapped_type mapped);

Parameter

key
Nilai kunci yang akan digunakan.

mapped
Nilai yang dipetakan untuk dicari.

Keterangan

Fungsi anggota mengembalikan value_type objek yang kuncinya adalah key dan yang nilainya dipetakan adalah mapped. Anda menggunakannya untuk menyusun objek yang cocok untuk digunakan dengan beberapa fungsi anggota lainnya.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::mapped_type

Jenis nilai yang dipetakan yang terkait dengan setiap kunci.

Sintaks

typedef Mapped mapped_type;

Keterangan

Jenisnya adalah sinonim untuk parameter Mappedtemplat .

Contoh

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

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

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

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

1 2 3

hash_map::max_load_factor

Mendapatkan atau mengatur elemen maksimum per wadah.

Sintaks

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

Parameter

new_factor
Faktor beban maksimum baru untuk disimpan.

Keterangan

Fungsi anggota pertama mengembalikan faktor beban maksimum yang disimpan saat ini. Anda menggunakannya untuk menentukan ukuran wadah rata-rata maksimum.

Fungsi anggota kedua menggantikan faktor beban maksimum penyimpanan dengan new_factor. Tidak ada pembuahan ulang otomatis yang terjadi sampai penyisipan berikutnya.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::operator=

Menggantikan urutan terkontrol.

Sintaks

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

Parameter

right
Kontainer untuk disalin.

Keterangan

Operator anggota menyalin right ke objek, lalu mengembalikan *this. Anda menggunakannya untuk mengganti urutan terkontrol dengan salinan urutan terkontrol di right.

Contoh

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

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

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

    // assign to a new container
    Myhash_map c2;
    c2 = c1;
// display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::operator[]

Memetakan kunci ke nilai yang dipetakan terkait.

Sintaks

mapped_type operator[](key_type key);

Parameter

key
Nilai kunci yang akan dicari.

Keterangan

Anggota berfungsi berusaha untuk menemukan elemen dengan urutan yang setara dengan key. Jika menemukannya, nilai yang dipetakan akan dikembalikan; jika tidak, ia menyisipkan value_type(key, mapped_type()) dan mengembalikan nilai yang dipetakan (default) terkait. Anda menggunakannya untuk mencari nilai yang dipetakan mengingat kunci terkaitnya, atau untuk memastikan bahwa entri ada untuk kunci jika tidak ada yang ditemukan.

Contoh

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

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

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

    System::Console::WriteLine("c1[{0}] = {1}",
        L'A', c1[L'A']);
    System::Console::WriteLine("c1[{0}] = {1}",
        L'b', c1[L'b']);

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

    // alter mapped values and redisplay
    c1[L'A'] = 10;
    c1[L'c'] = 13;
    for each (Myhash_map::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]
c1[A] = 0
c1[b] = 2
[a 1] [A 0] [b 2] [c 3]
[a 1] [A 10] [b 2] [c 13]

hash_map::rbegin

Menunjuk awal urutan terkontrol terbalik.

Sintaks

reverse_iterator rbegin();

Keterangan

Fungsi anggota mengembalikan iterator terbalik yang menunjuk elemen terakhir dari urutan yang dikontrol, atau tepat di luar awal urutan kosong. Oleh karena itu, ini menunjuk beginning urutan terbalik. Anda menggunakannya untuk mendapatkan iterator yang menunjuk current awal urutan terkontrol yang terlihat dalam urutan terbalik, tetapi statusnya dapat berubah jika panjang urutan terkontrol berubah.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::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_map::reference

Jenis referensi ke elemen.

Sintaks

typedef value_type% reference;

Keterangan

Jenis ini menjelaskan referensi ke elemen.

Contoh

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

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

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

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

hash_map::rehash

Membangun kembali tabel hash.

Sintaks

void rehash();

Keterangan

Fungsi anggota membangun kembali tabel hash, memastikan bahwa load_factor() <= max_load_factor(). Jika tidak, tabel hash meningkat ukurannya hanya sesuai kebutuhan setelah penyisipan. (Ukurannya tidak pernah menurun secara otomatis.) Anda menggunakannya untuk menyesuaikan ukuran tabel hash.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::rend

Menunjuk akhir urutan terkontrol terbalik.

Sintaks

reverse_iterator rend();

Keterangan

Fungsi anggota mengembalikan iterator terbalik yang menunjuk tepat di luar awal urutan yang dikontrol. Oleh karena itu, ini menunjuk end urutan terbalik. Anda menggunakannya untuk mendapatkan iterator yang menunjuk current akhir urutan terkontrol yang terlihat dalam urutan terbalik, tetapi statusnya dapat berubah jika panjang urutan terkontrol berubah.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::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_map::reverse_iterator

Jenis iterator terbalik untuk urutan yang dikontrol.

Sintaks

typedef T3 reverse_iterator;

Keterangan

Jenis menjelaskan objek jenis yang tidak ditentukan T3 yang dapat berfungsi sebagai iterator terbalik untuk urutan yang dikontrol.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_map::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_map::size

Menghitung jumlah elemen.

Sintaks

size_type size();

Keterangan

Fungsi anggota mengembalikan panjang urutan yang dikontrol. Anda menggunakannya untuk menentukan jumlah elemen yang saat ini berada dalam urutan terkontrol. Jika yang Anda pedulikan hanyalah apakah urutannya memiliki ukuran bukan nol, lihat hash_map::empty.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::make_value(L'd', 4));
    c1.insert(Myhash_map::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_map::size_type

Jenis jarak yang ditandatangani antara dua elemen.

Sintaks

typedef int size_type;

Keterangan

Jenis ini menjelaskan jumlah elemen non-negatif.

Contoh

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

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

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

    // compute positive difference
    Myhash_map::size_type diff = 0;
    for (Myhash_map::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_map::swap

Menukar isi dua kontainer.

Sintaks

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

Parameter

right
Kontainer untuk menukar konten dengan.

Keterangan

Fungsi anggota menukar urutan terkontrol antara this dan right. Ini melakukannya dalam waktu konstan dan tidak melemparkan pengecualian. Anda menggunakannya sebagai cara cepat untuk bertukar konten dua kontainer.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map c2;
    c2.insert(Myhash_map::make_value(L'd', 4));
    c2.insert(Myhash_map::make_value(L'e', 5));
    c2.insert(Myhash_map::make_value(L'f', 6));
    for each (Myhash_map::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_map::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    for each (Myhash_map::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_map::to_array

Menyalin urutan terkontrol ke array baru.

Sintaks

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

Keterangan

Fungsi anggota mengembalikan array yang berisi urutan terkontrol. Anda menggunakannya untuk mendapatkan salinan urutan terkontrol dalam bentuk array.

Contoh

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

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

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

    c1.insert(Myhash_map::make_value(L'd', 4));
    for each (Myhash_map::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_map::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_map::upper_bound

Menemukan akhir rentang yang cocok dengan kunci tertentu.

Sintaks

iterator upper_bound(key_type key);

Parameter

key
Nilai kunci yang akan dicari.

Keterangan

Fungsi anggota menentukan elemen X terakhir dalam urutan terkontrol yang hash ke wadah yang sama dengan key dan memiliki urutan yang setara dengan key. Jika tidak ada elemen seperti itu, atau jika X merupakan elemen terakhir dalam urutan yang dikontrol, elemen tersebut mengembalikan end(); jika tidak, elemen tersebut mengembalikan iterator yang menunjuk elemen pertama di luar X. Anda menggunakannya untuk menemukan akhir urutan elemen yang saat ini dalam urutan terkontrol yang cocok dengan kunci yang ditentukan.

Contoh

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

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

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_map::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_map::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_map::value_comp

Menyalin delegasi pengurutan untuk dua nilai elemen.

Sintaks

value_compare^ value_comp();

Keterangan

Fungsi anggota mengembalikan delegasi pengurutan yang digunakan untuk mengurutkan urutan yang dikontrol. Anda menggunakannya untuk membandingkan dua nilai elemen.

Contoh

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

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

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'b', 2),
            Myhash_map::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_map::value_compare

Delegasi pengurutan untuk dua nilai elemen.

Sintaks

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

Keterangan

Jenis adalah sinonim untuk delegasi yang menentukan urutan argumen nilainya.

Contoh

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

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

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_map::make_value(L'a', 1),
            Myhash_map::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_map::make_value(L'b', 2),
            Myhash_map::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_map::value_type

Jenis elemen.

Sintaks

typedef generic_value value_type;

Keterangan

Jenisnya adalah sinonim untuk generic_value.

Contoh

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

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

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

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