`unordered_map` 類別

發行項
06/16/2023

類別範本描述一個物件，該物件會控制型 std::pair<const Key, Ty>別元素的不同長度序列。序列由雜湊函式弱式排序，將序列分割為子序列的已排序集合，稱為 Bucket。在每個貯體內，比較函式會決定任何一組元素是否具有對等的順序。每個項目儲存兩個物件：排序鍵和值。序列是以允許查閱、插入和移除任意元素的方式表示，其作業與序列中元素數目無關（常數時間），至少當所有貯體長度大致相等時。在最壞的情況下，當所有項目都在一個 Bucket 時，作業數目與序列中的項目數目成正比 (線性時間)。此外，插入元素不會使反覆運算器失效，而移除元素只會使指向已移除元素的反覆運算器失效。

語法

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

參數

Key
索引鍵類型。

Ty
對應的類型。

Hash
雜湊函式物件類型。

Pred
相等比較函式物件類型。

Alloc
配置器類別。

成員

類型定義	描述
`allocator_type`	管理儲存體的配置器類型。
`const_iterator`	用於受控制序列的常數迭代器類型。
`const_local_iterator`	用於受控制序列的常數 Bucket 迭代器類型。
`const_pointer`	項目的常數指標類型。
`const_reference`	項目的常數參考類型。
`difference_type`	兩個項目之間帶正負號距離的類型。
`hasher`	雜湊函式的類型。
`iterator`	受控制序列之迭代器的類型。
`key_equal`	比較函式的類型。
`key_type`	排序索引鍵的類型。
`local_iterator`	用於受控制序列的 Bucket 迭代器類型。
`mapped_type`	與每個索引鍵關聯的對應值類型。
`pointer`	項目的指標類型。
`reference`	項目的參考類型。
`size_type`	兩個項目之間不帶正負號距離的類型。
`value_type`	元素的類型。

成員函式	描述
`at`	尋找具有指定之索引鍵的項目。
`begin`	指定受控制序列的開頭。
`bucket`	取得索引鍵值的值區數目。
`bucket_count`	取得 Bucket 的數目。
`bucket_size`	取得 Bucket 大小。
`cbegin`	指定受控制序列的開頭。
`cend`	指定受控制序列的結尾。
`clear`	移除所有項目。
`count`	尋找符合指定索引鍵的項目數目。
`contains`^C++20	檢查中是否有具有指定索引鍵 `unordered_map`的專案。
`emplace`	加入就地建構的項目。
`emplace_hint`	加入就地建構的項目，含提示。
`empty`	測試項目是否不存在。
`end`	指定受控制序列的結尾。
`equal_range`	尋找符合指定之索引鍵的範圍。
`erase`	移除位於指定位置的項目。
`find`	尋找符合指定之索引鍵的元素。
`get_allocator`	取得已儲存的配置器物件。
`hash_function`	取得儲存的雜湊函式物件。
`insert`	加入項目。
`key_eq`	取得儲存的比較函式物件。
`load_factor`	計算每個值區的平均項目數。
`max_bucket_count`	取得 Bucket 最大數目。
`max_load_factor`	取得或設定每個 Bucket 最大項目數。
`max_size`	取得受控制序列的大小上限。
`rehash`	重建雜湊資料表。
`size`	計算元素的數目。
`swap`	交換兩個容器的內容。
`unordered_map`	建構容器物件。

Operator	描述
`unordered_map::operator[]`	尋找或插入具有指定索引鍵的項目。
`unordered_map::operator=`	複製雜湊資料表。

備註

物件會呼叫兩個預存物件、類型的 unordered_map::key_equal 比較函式對象和類型的 unordered_map::hasher哈希函式物件，來排序它所控制的順序。您可以藉由呼叫成員函 unordered_map::key_eq()式來存取第一個預存物件;而您可以藉由呼叫成員函 unordered_map::hash_function()式來存取第二個預存物件。具體來說，只有在兩個引數值具有對等順序，對於 X 類型的所有值 Y 和 Key，呼叫 key_eq()(X, Y) 才會傳回 true，呼叫 hash_function()(keyval) 會產生 size_t 類型值的分佈。不同於類別範本 unordered_multimap 類別，類型的 unordered_map 對象可確保 key_eq()(X, Y) 受控制序列的任何兩個專案一律為 false。 (索引鍵是唯一的)。

物件也會儲存最大載入因數，指定每個 Bucket 所需的項目平均數目上限。如果插入專案會導致 unordered_map::load_factor() 超過最大負載因數，容器會增加貯體數目，並視需要重建哈希表。

受控制序列中實際的項目順序取決於雜湊函式、比較函式、插入順序、最大載入因數和 Bucket 目前數目。您通常無法預測受控制序列中的元素順序。不過，您永遠可以確保，有對等順序的任何項目子集在受控制序列中為相鄰。

物件會透過類型的 unordered_map::allocator_type預存配置器物件，為它所控制的順序配置和釋放記憶體。這類配置器對象必須與類型的 allocator物件具有相同的外部介面。指派容器物件時，不會複製預存的配置器物件。

需求

標頭： <unordered_map>

命名空間：std

`unordered_map::allocator_type`

管理儲存體的配置器類型。

typedef Alloc allocator_type;

備註

此類型是範本參數 Alloc的同義字。

範例

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

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

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

    return (0);
}

al == std::allocator() is true

`unordered_map::at`

在 unordered_map 中尋找具有指定索引鍵值的項目。

Ty& at(const Key& key);
const Ty& at(const Key& key) const;

參數

key
要尋找的索引鍵值。

傳回值

所找到項目之資料值的參考。

備註

如果找不到自變數索引鍵值，則函式會擲回類別 out_of_range的物件。

範例

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

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

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

    // find and show elements
    std::cout << "c1.at('a') == " << c1.at('a') << std::endl;
    std::cout << "c1.at('b') == " << c1.at('b') << std::endl;
    std::cout << "c1.at('c') == " << c1.at('c') << std::endl;

    return (0);
}

`unordered_map::begin`

指定受控制序列或值區的開頭。

iterator begin();
const_iterator begin() const;
local_iterator begin(size_type nbucket);
const_local_iterator begin(size_type nbucket) const;

參數

nbucket
值區數目。

備註

最前面兩個成員函式傳回的正向迭代器，指向序列的第一個項目 (或在空序列結尾以外的位置)。最後面兩個成員函式傳回的正向迭代器，指向值區 nbucket 的第一個項目 (或在空值區結尾以外的位置)。

範例

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

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

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

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

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

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

    return (0);
}

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

`unordered_map::bucket`

取得索引鍵值的值區數目。

size_type bucket(const Key& keyval) const;

參數

keyval
要對應的索引鍵值。

備註

此成員函式會傳回目前對應至索引鍵值 keyval的值區數目。

範例

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

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

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

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

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

    return (0);
}

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

`unordered_map::bucket_count`

取得 Bucket 的數目。

size_type bucket_count() const;

備註

成員函式會傳回目前的 Bucket 數目。

範例

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

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

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

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

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

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

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

    return (0);
}

[c, 3][b, 2][a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

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

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

`unordered_map::bucket_size`

取得 Bucket 大小

size_type bucket_size(size_type nbucket) const;

參數

nbucket
值區數目。

備註

成員函式會傳回值區編號 nbucket的大小。

範例

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

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

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

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

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

    return (0);
}

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

`unordered_map::cbegin`

傳回 const 迭代器，為範圍中的第一個項目定址。

const_iterator cbegin() const;

傳回值

const 正向存取迭代器，指向範圍的第一個項目，或指向空白範圍結尾 (空白範圍 cbegin() == cend()) 之外的位置。

備註

使用的 cbegin傳回值，就無法修改範圍中的專案。

您可以使用此成員函式取代 begin() 成員函式，以確保傳回值是 const_iterator。一般而言，它會與類型推算關鍵詞搭配 auto 使用，如下列範例所示。在此範例中，請考慮將 Container 視為任何支援 begin() 和 cbegin() 且可修改 (非 const) 的容器類型。

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

// i2 is Container<T>::const_iterator

`unordered_map::cend`

傳回 const 迭代器，為範圍中最後一個項目之外的位置定址。

const_iterator cend() const;

傳回值

指向範圍結尾之外的 const 正向存取迭代器。

備註

cend 用來測試迭代器是否已超過其範圍結尾。

您可以使用此成員函式取代 end() 成員函式，以確保傳回值是 const_iterator。一般而言，它會與類型推算關鍵詞搭配 auto 使用，如下列範例所示。在此範例中，請考慮將 Container 視為任何支援 end() 和 cend() 且可修改 (非 const) 的容器類型。

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

所 cend 傳回的值不應該取值。

`unordered_map::clear`

移除所有項目。

void clear();

備註

成員函式會呼叫 unordered_map::erase(unordered_map::begin(), unordered_map::end())、，請參閱 unordered_map::erase、 unordered_map::begin和 unordered_map::end。

範例

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

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

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

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

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

    c1.insert(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

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

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

    return (0);
}

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

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

`unordered_map::const_iterator`

用於受控制序列的常數迭代器類型。

typedef T1 const_iterator;

備註

此類型說明可做為受控制序列之常數正向迭代器的物件。這裡描述為實作定義型別的同義字 T1。

範例

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

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

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

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

    return (0);
}

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

`unordered_map::const_local_iterator`

用於受控制序列的常數 Bucket 迭代器類型。

typedef T5 const_local_iterator;

備註

此類型說明可作為值區之常數正向迭代器的物件。這裡描述為實作定義型別的同義字 T5。

範例

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

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

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

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

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

    return (0);
}

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

`unordered_map::const_pointer`

項目的常數指標類型。

typedef Alloc::const_pointer const_pointer;

備註

此類型所說明的物件可做為受控制序列之項目的常數指標。

範例

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

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

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

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

    return (0);
}

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

`unordered_map::const_reference`

項目的常數參考類型。

typedef Alloc::const_reference const_reference;

備註

此類型所說明的物件可作為受控制序列之元素的常數參考。

範例

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

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

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

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

    return (0);
}

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

`unordered_map::contains`

檢查中 unordered_map 是否有具有指定索引鍵的專案。 C++20 中引進。

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

參數

K
索引鍵的類型。

key
要尋找之專案的索引鍵值。

傳回值

true 如果在容器中找到專案，則為 ; false 否則。

備註

contains() 是 C++20 中的新功能。若要使用它，請指定 /std:c++20 或更新版本的編譯程序選項。

template<class K> bool contains(const K& key) const 只有在透明時 key_compare 才會參與多載解析。

範例

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

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

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

    return 0;
}

true
false

`unordered_map::count`

尋找符合指定索引鍵的項目數目。

size_type count(const Key& keyval) const;

參數

keyval
要搜尋的索引鍵值。

備註

成員函式會傳回以分隔 unordered_map::equal_range(keyval)範圍中的項目數。

範例

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

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

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

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

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

    return (0);
}

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

`unordered_map::difference_type`

兩個項目之間帶正負號距離的類型。

typedef T3 difference_type;

備註

此帶正負號的整數類型所描述的物件可代表受控制序列中任何兩個項目位址之間的差距。這裡描述為實作定義型別的同義字 T3。

範例

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

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

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

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

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

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

    return (0);
}

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

`unordered_map::emplace`

將就地建構元素 (沒有執行複製或移動作業) 插入到 unordered_map。

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

參數

args
轉送的自變數會建構要插入至 unordered_map 的專案，除非它已經包含其值相等排序的專案。

傳回值

如果已插入，pair 的 bool 元件就會傳回 true，如果 unordered_map 已經包含元素，其中該元素的索引鍵具有對等的排序值，且其迭代器元件傳回插入新元件或該元素已在的位址，則會傳回 false。

若要存取此成員函式所傳回的配對 pr 迭代器元件，請使用 pr.first，若要取其值，請使用 *(pr.first)。若要存取此成員函式所傳回之配對 pr 的 bool 元件，請使用 pr.second.

備註

此函式不會使任何迭代器或參考失效。

在插入期間，如果擲回例外狀況，但不會發生在容器的哈希函式中，則不會修改容器。若雜湊函式中擲回例外狀況，則結果為未定義。

如需程式碼範例，請參閱map::emplace。

`unordered_map::emplace_hint`

將就地建構 (未執行任何複製或移動作業) 的元素連同位置提示一起插入。

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

參數

args
轉送以建構插入 unordered_map 之元素的引數，除非該 unordered_map 中已經包含該元素，或廣義而言，除非它已經包含索引鍵以同等方式排序的元素。

where
一個有關要從哪裡開始搜尋正確插入點的提示。

傳回值

指向新插入之元素的迭代器。

如果插入因為項目已經存在而失敗，則會將迭代器傳回現有的項目。

備註

此函式不會使任何參考無效。

在插入期間，如果擲回例外狀況，但不會發生在容器的哈希函式中，則不會修改容器。若雜湊函式中擲回例外狀況，則結果為未定義。

value_type專案的是一對，因此元素的值會是排序的配對，第一個元件等於索引鍵值，而第二個元件等於專案的數據值。

如需程式碼範例，請參閱map::emplace_hint。

`unordered_map::empty`

測試項目是否不存在。

bool empty() const;

備註

成員函式會對空的受控制序列傳回 true。

範例

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

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

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

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

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

    c1.insert(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

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

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

    return (0);
}

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

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

`unordered_map::end`

指定受控制序列的結尾。

iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;

參數

nbucket
值區數目。

備註

前兩個成員函式會傳回指向序列結尾之外的正向迭代器。最後兩個成員函式會傳回指向值區 nbucket結尾之外的正向迭代器。

`unordered_map::equal_range`

尋找符合指定之索引鍵的範圍。

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

參數

keyval
要搜尋的索引鍵值。

備註

此成員函式會傳回一組迭代器 X ，使 [X.first, X.second) 僅分隔與 keyval具有相同順序之受控制序列的項目。如果沒有這類項目存在，則兩個迭代器皆為 end()。

範例

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

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

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

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

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

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

    return (0);
}

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

`unordered_map::erase`

從指定的位置移除 unordered_map 中的元素或元素範圍，或移除符合指定索引鍵的元素。

iterator erase(const_iterator Where);
iterator erase(const_iterator First, const_iterator Last);
size_type erase(const key_type& Key);

參數

Where
要移除之項目的位置。

First
要移除之第一個項目的位置。

Last
緊接在要移除之最後一個項目後面的位置。

Key
要移除之項目的索引鍵值。

傳回值

針對前兩個成員函式，會傳回雙向迭代器，其中指定任何移除之元素後剩餘的第一個元素，或如果沒有這類元素，則傳回 map 結尾的元素。

在第三個成員函式中，傳回已從 unordered_map 移除的元素數。

備註

如需程式碼範例，請參閱map::erase。

unordered_map::find

尋找符合指定之索引鍵的元素。

const_iterator find(const Key& keyval) const;

參數

keyval
要搜尋的索引鍵值。

備註

此成員函式會傳回 unordered_map::equal_range(keyval).first。

範例

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

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

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

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

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

    // try to find and succeed
    Mymap::iterator it = c1.find('b');
    std::cout << "find('b') == "
        << std::boolalpha << (it != c1.end())
        << ": [" << it->first << ", " << it->second << "]" << std::endl;

    return (0);
}

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

`unordered_map::get_allocator`

取得已儲存的配置器物件。

Alloc get_allocator() const;

備註

這個成員函式會傳回儲存的配置器物件。

範例

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

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

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

    return (0);
}

al == std::allocator() is true

`unordered_map::hash_function`

取得儲存的雜湊函式物件。

Hash hash_function() const;

備註

此成員函式會傳回儲存的雜湊函式物件。

範例

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

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

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

    return (0);
}

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

`unordered_map::hasher`

雜湊函式的類型。

typedef Hash hasher;

備註

此類型是範本參數 Hash的同義字。

範例

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

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

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

    return (0);
}

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

`unordered_map::insert`

將某個項目或項目範圍插入 unordered_map 中。

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

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

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

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

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

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

參數

Val
除非其中包含了索引鍵已經過對等地排序的項目，否則為要插入 unordered_map 中的項目值。

Where
要開始搜尋正確的插入點的地方。

ValTy
樣板參數，指定unordered_map可用來建構的專案 value_type，並將完美轉送 Val 做為自變數。

First
要複製之第一個元素的位置。

Last
要複製之最一個元素後方的位置。

InputIterator
符合輸入反覆運算器需求的樣板函式自變數，指向可用來建構value_type物件之型別的專案。

IList
initializer_list要從複製項目的。

傳回值

單一元素成員函式（1）和（2）會傳回，其元件是在true進行插入時傳回，如果 false unordered_map 已經包含索引鍵具有排序中相等值的專案，則傳回。boolpair 如果bool元件為，則傳回值組的反覆運算器元件會指向新插入的專案，如果bool元件為 truefalse，則指向現有專案。

具有提示的單一項目成員函式 (3) 及 (4) 會傳回指向位置的迭代器，該位置是新項目插入 unordered_map 中的位置，或者，若對等索引鍵已存在，則指向現有項目。

備註

此函式不會使任何迭代器、指標或參考無效。

在只插入一個項目期間，如果擲回例外狀況，但不會發生在容器的哈希函式中，則不會修改容器的狀態。若雜湊函式中擲回例外狀況，則結果為未定義。在插入多個元素期間，若擲出例外狀況，則容器會處於未指定但有效的狀態。

若要存取單一元素成員函式所傳回之 pair pr 的反覆運算器元件，請使用 ;若要取值傳回配對內的反覆運算器，請使用 pr.first*pr.first，提供元素。若要存取 bool 元件，請使用 pr.second。例如，請參閱本文中稍後的範例程式碼。

value_type容器的是屬於容器的 typedef，而對應map<K, V>::value_type則為 pair<const K, V>。元素的值是已排序的配對，其中第一個元件等於索引鍵值，而第二個元件等於元素的資料值。

範圍成員函式（5）會將專案值序列插入unordered_map，對應至範圍 [First, Last)中反覆運算器所尋址的每個專案; Last 因此不會插入。容器成員函式 end() 會參考容器中最後一個項目之後的位置。例如陳述式 m.insert(v.begin(), v.end()); 嘗試將 v 的所有項目插入 m。只會插入具有範圍中唯一值的元素；若重複則會忽略。若要觀察哪些元素會遭到拒絕，請使用單一元素版本的 insert。

初始化表示式清單成員函式（6）會使用 initializer_list 將專案複製到unordered_map。

若要插入就地建構的專案，也就是不會執行任何複製或移動作業，請參閱 unordered_map::emplace 和 unordered_map::emplace_hint。

如需程式碼範例，請參閱map::insert。

`unordered_map::iterator`

受控制序列之迭代器的類型。

typedef T0 iterator;

備註

此類型說明可作為受控制序列之正向迭代器的物件。這裡描述為實作定義型別的同義字 T0。

範例

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

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

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

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

    return (0);
    }

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

`unordered_map::key_eq`

取得儲存的比較函式物件。

Pred key_eq() const;

備註

此成員函式會傳回儲存的比較函式物件

範例

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

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

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

    return (0);
    }

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

`unordered_map::key_equal`

比較函式的類型。

typedef Pred key_equal;

備註

此類型是範本參數 Pred的同義字。

範例

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

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

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

    return (0);
    }

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

`unordered_map::key_type`

排序索引鍵的類型。

typedef Key key_type;

備註

此類型是範本參數 Key的同義字。

範例

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

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

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

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

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

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

    return (0);
    }

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

`unordered_map::load_factor`

計算每個值區的平均項目數。

float load_factor() const;

備註

成員函式會傳 (float)unordered_map::size() / (float)unordered_map::bucket_count()回，每個貯體的平均元素數目，請參閱 unordered_map::size 和 unordered_map::bucket_count。

範例

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

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

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

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

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

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

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

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

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

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

`unordered_map::local_iterator`

值區迭代器的類型。

typedef T4 local_iterator;

備註

此類型說明可做為值區之正向迭代器的物件。這裡描述為實作定義型別的同義字 T4。

範例

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

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

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

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

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

    return (0);
    }

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

`unordered_map::mapped_type`

與每個索引鍵關聯的對應值類型。

typedef Ty mapped_type;

備註

此類型是範本參數 Ty的同義字。

範例

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

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

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

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

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

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

    return (0);
    }

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

`unordered_map::max_bucket_count`

取得 Bucket 最大數目。

size_type max_bucket_count() const;

備註

此成員函式會傳回目前允許的最大值區數目。

範例

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

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

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

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

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

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

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

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

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

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

`unordered_map::max_load_factor`

取得或設定每個 Bucket 最大項目數。

float max_load_factor() const;

void max_load_factor(float factor);

參數

factor
新的最大載入因數。

備註

第一個成員函式會傳回儲存的最大載入因數。第二個成員函式會以 factor取代儲存的最大載入因數。

範例

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

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

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

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

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

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

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

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

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

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

`unordered_map::max_size`

取得受控制序列的大小上限。

size_type max_size() const;

備註

此成員函式會傳回物件可以控制之最長序列的長度。

範例

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

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

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

    return (0);
    }

max_size() == 536870911

`unordered_map::operator[]`

尋找或插入具有指定索引鍵的項目。

Ty& operator[](const Key& keyval);

Ty& operator[](Key&& keyval);

參數

keyval
要尋找或插入的索引鍵值。

傳回值

所插入項目之資料值的參考。

備註

如果找不到自變數索引鍵值，則會與數據類型的預設值一起插入。

operator[] 可用來將元素插入到對應 m 中，方法是使用 m[Key] = DataValue;，其中 DataValue 是索引鍵值為 Key 之元素的 mapped_type 值。

成員函式會將反覆運算器 where 判斷為的 unordered_map::insert(unordered_map::value_type(keyval, Ty())傳回值。如需詳細資訊，請參閱 unordered_map::insert 和 unordered_map::value_type。（如果不存在這類專案，則會插入具有指定索引鍵的專案。然後，它會傳回的 (*where).second參考。

使用 operator[] 插入專案時，傳回的參考不會指出插入是變更既有項目還是建立新的專案。成員函式 find 和 insert 可用來判斷具有指定索引鍵的專案是否已經在插入之前存在。

範例

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

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

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

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

// try to find and fail
    std::cout << "c1['A'] == " << c1['A'] << std::endl;

// try to find and succeed
    std::cout << "c1['a'] == " << c1['a'] << std::endl;

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

// insert by moving key
    std::unordered_map<string, int> c2;
    std::string str("abc");
    std::cout << "c2[std::move(str)] == " << c2[std::move(str)] << std::endl;
    std::cout << "c2["abc"] == " << c2["abc"] << std::endl;

    return (0);
    }

[c, 3] [b, 2] [a, 1]
c1['A'] == 0
c1['a'] == 1
[c, 3] [b, 2] [A, 0] [a, 1]
c2[move(str)] == 0
c2["abc"] == 1

`unordered_map::operator=`

使用來自另一個 unordered_map 的項目來取代這個 unordered_map 的項目。

unordered_map& operator=(const unordered_map& right);

unordered_map& operator=(unordered_map&& right);

參數

right
此運算子函式從中指派內容的 unordered_map。

備註

第一個版本會將 right 中的所有元素複製到這個 unordered_map。

第二個版本會將 right 中的所有元素移至這個 unordered_map。

捨棄執行之前 operator= 在此unordered_map中的任何專案。

範例

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

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

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

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

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

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

`unordered_map::pointer`

項目的指標類型。

typedef Alloc::pointer pointer;

備註

此類型所說明的物件可做為受控制序列之項目的指標。

範例

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

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

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

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

    return (0);
    }

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

`unordered_map::reference`

項目的參考類型。

typedef Alloc::reference reference;

備註

此類型所說明的物件可做為受控制序列之元素的參考。

範例

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

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

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

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

    return (0);
    }

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

`unordered_map::rehash`

重建雜湊資料表。

void rehash(size_type nbuckets);

參數

nbuckets
要求的值區數目。

備註

此成員函式會將值區數目改變為至少 nbuckets ，並視需要重建雜湊資料表。

範例

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

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

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

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

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

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

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

    return (0);
    }

[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4

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

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

`unordered_map::size`

計算元素的數目。

size_type size() const;

備註

成員函式會傳回受控制序列的長度。

範例

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

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

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

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

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

    c1.insert(Mymap::value_type('d', 4));
    c1.insert(Mymap::value_type('e', 5));

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

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

    return (0);
    }

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

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

`unordered_map::size_type`

兩個項目之間不帶正負號距離的類型。

typedef T2 size_type;

備註

此不帶正負號的整數類型所描述的物件可代表任何受控制序列的長度。這裡描述為實作定義型別的同義字 T2。

範例

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

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

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

    return (0);
    }

size == 0

`unordered_map::swap`

交換兩個容器的內容。

void swap(unordered_map& right);

參數

right
要交換的容器。

備註

成員函式會交換 *this 和 right 之間受控制的序列。如果 unordered_map::get_allocator() == right.get_allocator()為，請參閱 unordered_map::get_allocator，它會在常數時間執行此作業，只會因為複製類型的 Tr預存特性對象而擲回例外狀況，而且不會使指定兩個受控制序列中元素的參考、指標或反覆運算器失效。否則，它會執行與兩個受控制序列中元素數目成正比的元素指派和建構函式呼叫。

範例

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

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

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

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

    Mymap c2;

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

    c1.swap(c2);

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

    swap(c1, c2);

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

    return (0);
    }

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

`unordered_map::unordered_map`

建構容器物件。

unordered_map(const unordered_map& Right);

explicit unordered_map(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Allocator());

unordered_map(unordered_map&& Right);
unordered_map(initializer_list<Type> IList);
unordered_map(initializer_list<Type> IList, size_type Bucket_count);

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

unordered_map(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    KeyEqual& equal);

unordered_map(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    KeyEqual& Equal
    const Allocator& Al);

template <class InIt>
unordered_map(
    InputIterator First,
    InputIterator Last,
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

參數

Al
要儲存的配置器物件。

Comp
要儲存的比較函式物件。

Hash
要儲存的雜湊函式物件。

Bucket_count
Bucket 最小數目。

Right
要複製的容器。

First
要複製之第一個元素的位置。

Last
要複製之最一個元素後方的位置。

IList
包含要複製之項目的 initializer_list。

備註

第一個建構函式指定由 right 控制之序列的複本。第二個建構函式會指定空白的受控制序列。第三個建構函式會插入項目值序列 [first, last)。第四個建構函式透過移動 right 來指定序列的複本。

所有建構函式也會初始化數個儲存值。對於複製建構函式，其值是從 Right 取得。否則:

如果存在，則值區數目下限為自變數 Bucket_count，否則為這裡描述為實作定義值的 N0預設值。

哈希函式物件是自變數 Hash，如果存在則為，否則為 Hash()。

比較函式物件是自變數 Comp，如果存在則為，否則為 Pred()。

設定器物件是自變數 Al，如果存在，則為，否則為 Alloc()。

範例

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

using namespace std;

using Mymap = unordered_map<char, int>;

int main()
{
    Mymap c1;

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

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

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

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

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

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

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

    Mymap c4(move(c3));

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

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

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

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

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

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

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

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

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

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

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

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

`unordered_map::value_type`

元素的類型。

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

備註

此類型描述受控制序列的項目。

範例

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

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

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

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

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

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

    return (0);
}

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

另請參閱

<unordered_map>
C++ 標準程式庫中的執行緒安全\

共用方式為

unordered_map 類別

語法

參數

成員

備註

需求

unordered_map::allocator_type

備註

範例

unordered_map::at

參數

傳回值

備註

範例

unordered_map::begin

參數

備註

範例

unordered_map::bucket

參數

備註

範例

unordered_map::bucket_count

備註

範例

unordered_map::bucket_size

參數

備註

範例

unordered_map::cbegin

傳回值

備註

unordered_map::cend

傳回值

備註

unordered_map::clear

備註

範例

unordered_map::const_iterator

備註

範例

unordered_map::const_local_iterator

備註

範例

unordered_map::const_pointer

備註

範例

unordered_map::const_reference

備註

範例

unordered_map::contains

參數

傳回值

備註

範例

unordered_map::count

參數

備註

範例

unordered_map::difference_type

備註

範例

unordered_map::emplace

參數

傳回值

備註

unordered_map::emplace_hint

參數

傳回值

備註

unordered_map::empty

備註

範例

unordered_map::end

參數

備註

unordered_map::equal_range

參數

備註

`unordered_map` 類別

`unordered_map::allocator_type`

`unordered_map::at`

`unordered_map::begin`

`unordered_map::bucket`

`unordered_map::bucket_count`

`unordered_map::bucket_size`

`unordered_map::cbegin`

`unordered_map::cend`

`unordered_map::clear`

`unordered_map::const_iterator`

`unordered_map::const_local_iterator`

`unordered_map::const_pointer`

`unordered_map::const_reference`

`unordered_map::contains`

`unordered_map::count`

`unordered_map::difference_type`

`unordered_map::emplace`

`unordered_map::emplace_hint`

`unordered_map::empty`

`unordered_map::end`

`unordered_map::equal_range`

`unordered_map::erase`

`unordered_map::get_allocator`

`unordered_map::hash_function`

`unordered_map::hasher`

`unordered_map::insert`

`unordered_map::iterator`

`unordered_map::key_eq`

`unordered_map::key_equal`

`unordered_map::key_type`

`unordered_map::load_factor`

`unordered_map::local_iterator`

`unordered_map::mapped_type`

`unordered_map::max_bucket_count`

`unordered_map::max_load_factor`

`unordered_map::max_size`

`unordered_map::operator[]`

`unordered_map::operator=`

`unordered_map::pointer`

`unordered_map::reference`

`unordered_map::rehash`