`unordered_map` 类

项目
10/12/2023

此类模板描述用于控制 std::pair<const Key, Ty> 类型的变长元素序列的对象。序列由哈希函数弱排序，哈希函数将此序列分区到称为存储桶的有序序列集中。在每个存储桶中，比较函数将确定任一元素对是否具有等效顺序。每个元素存储两个对象，包括一个排序键和一个值。序列以允许查找、插入和移除任意元素的方式表示，并包含与序列中的元素数量无关的操作（常量时间），至少在所有存储桶长度大致相等时如此。在最坏情况下，当所有元素位于一个存储桶中时，操作数量与序列中的元素数量成比例（线性时间）。此外，插入元素不会使迭代器失效，移除元素仅会使指向已移除元素的迭代器失效。

语法

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 类。

成员

类型定义	说明
`allocator_type`	用于管理存储的分配器的类型。
`const_iterator`	受控序列的常量迭代器的类型。
`const_local_iterator`	受控序列的常量存储桶迭代器的类型。
`const_pointer`	元素的常量指针的类型。
`const_reference`	元素的常量引用的类型。
`difference_type`	两个元素间的带符号距离的类型。
`hasher`	哈希函数的类型。
`iterator`	受控序列的迭代器的类型。
`key_equal`	比较函数的类型。
`key_type`	排序键的类型。
`local_iterator`	受控序列的存储桶迭代器的类型。
`mapped_type`	与每个键关联的映射值的类型。
`pointer`	指向元素的指针的类型。
`reference`	元素的引用的类型。
`size_type`	两个元素间的无符号距离的类型。
`value_type`	元素的类型。

成员函数	说明
`at`	查找具有指定键的元素。
`begin`	指定受控序列的开头。
`bucket`	获取键值的存储桶编号。
`bucket_count`	获取存储桶数。
`bucket_size`	获取存储桶的大小。
`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`	获取最大的存储桶数。
`max_load_factor`	获取或设置每个存储桶的最多元素数。
`max_size`	获取受控序列的最大大小。
`rehash`	重新生成哈希表。
`size`	对元素数进行计数。
`swap`	交换两个容器的内容。
`unordered_map`	构造容器对象。

运算符	说明
`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。（键是唯一的。）

此对象还存储最大加载因子，用于指定每个存储桶的元素的最大所需平均数量。如果插入元素导致 unordered_map::load_factor() 超出最大加载因子，容器将增加存储桶的数量并根据需要重新生成哈希表。

受控序列中元素的实际顺序取决于哈希函数、比较函数、插入顺序、最大加载因子和存储桶的当前数量。通常无法预测受控序列中的元素顺序。但是，可以始终确保具有等效顺序的任何元素子集在受控序列中相邻。

对象通过 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`

获取存储桶数。

size_type bucket_count() const;

备注

该成员函数将返回存储桶的当前数量。

示例

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

获取存储桶的大小

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`

受控序列的常量存储桶迭代器的类型。

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 或更高版本编译器选项。

如果 key_compare 是透明的，则 template<class K> bool contains(const K& key) const 仅参与重载决策。

示例

// 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 中的元素的转发参数（除非它已包含一个具有相对有序的值的元素）。

返回值

如果完成插入操作，则包含 bool 组件的 pair 返回 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) 将返回 pair，如果完成插入，则其 bool 组件为 true；如果 unordered_map 已经包含一个其键在排序中具有等效值的元素，则为 false。返回值对的迭代器组件将指向新插入的元素（如果 bool 组件为 true）或现有元素（如果 bool 组件为 false）。

附带提示的单个元素的成员函数 (3) 和 (4) 返回迭代器，该迭代器指向将新元素插入到 unordered_map 中的位置，如果具有等效键的元素已经存在，则指向现有元素。

备注

任何迭代器、指针或引用都不会因为此函数而失效。

在只插入单个元素的过程中，如果引发异常，但是异常并未在容器的哈希函数中发生，则不会修改该容器的状态。如果在哈希函数中引发异常，则未定义此结果。在插入多个元素的过程中，如果引发异常，则会使容器处于未指定但有效的状态。

若要访问由单元素成员函数返回的pairpr迭代器组件，请使用 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`

获取最大的存储桶数。

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`

获取或设置每个存储桶的最多元素数。

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[Key] = DataValue;（其中 DataValue 是具有键值 Key 的元素 mapped_type 的值）的 map m。

成员函数将迭代器 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= executes 之前此 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
存储桶的最少数量。

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`