C++容器 II 无序映射

template < class Key,                                    // unordered_map::key_type
           class T,                                      // unordered_map::mapped_type
           class Hash = hash<Key>,                       // unordered_map::hasher
           class Pred = equal_to<Key>,                   // unordered_map::key_equal
           class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
           > class unordered_map;

模板参数【Template parameters】

Key

键值的类型。无序_映射中的每个元素都由其键值唯一标识。

别名为成员类型无序_映射：：键_类型。

T

映射值的类型。无序_映射中的每个元素都用于存储一些数据作为其映射值。

别名为成员类型无序_映射：：映射_类型。请注意，这与无序映射：：值类型（见下文）不同。

Hash

一元函数对象类型，它以key类型的对象作为参数，并基于它返回size\u t类型的唯一值。这可以是实现函数调用运算符的类，也可以是指向函数的指针（参见构造函数的示例）。这默认为hash，它返回一个冲突概率接近1.0/std:：numeric_limits<size_t>：：max（）的哈希值。

无序的_map对象使用此函数返回的哈希值在内部组织其元素，从而加快查找单个元素的过程。

别名为成员类型unordered_map:：hasher。

Pred

一种二进制谓词，它接受两个键类型的参数并返回布尔值。表达式pred（a，b），其中pred是这种类型的对象，a和b是键值，如果认为a等同于b，则应返回true。这可以是实现函数调用运算符的类，也可以是指向函数的指针（参见构造函数的示例）。这默认为equal_to，返回的值与应用equal to运算符（a==b）相同。

无序的_映射对象使用此表达式确定两个元素键是否相等。无序映射容器中的任何两个元素都不能有使用此谓词生成true的键。

别名为成员类型无序映射：：key_equal。

Alloc

用于定义存储分配模型的分配器对象的类型。默认情况下，使用分配器类模板，它定义了最简单的内存分配模型，并且与值无关。

别名为成员类型无序_映射：：分配器_类型。

无序映射【Unordered Map】

Unordered maps are associative containers that store elements formed by the combination of a key value and a mapped value, and which allows for fast retrieval of individual elements based on their keys.

无序映射是一种关联容器，用于存储由键值和映射值组合而成的元素，并允许基于其键快速检索单个元素。

In an unordered_map, the key value is generally used to uniquely identify the element, while the mapped value is an object with the content associated to this key. Types of key and mapped value may differ.

在无序的_映射中，键值通常用于唯一标识元素，而映射值是一个对象，其内容与该键值关联。键和映射值的类型可能不同。

Internally, the elements in the unordered_map are not sorted in any particular order with respect to either their key or mapped values, but organized into buckets depending on their hash values to allow for fast access to individual elements directly by their key values (with a constant average time complexity on average).

在内部，无序_映射中的元素不会按照其键或映射值的任何特定顺序进行排序，而是根据它们的散列值组织到存储桶中，以允许直接通过它们的键值快速访问单个元素（平均时间复杂度恒定）。

unordered_map containers are faster than map containers to access individual elements by their key, although they are generally less efficient for range iteration through a subset of their elements.

无序映射容器通过键访问单个元素的速度比映射容器快，尽管它们通过元素子集进行范围迭代的效率通常较低。

Unordered maps implement the direct access operator (operator[]) which allows for direct access of the mapped value using its key value as argument.

无序映射实现直接访问运算符（运算符[]），该运算符允许使用映射值的键值作为参数直接访问映射值。

Iterators in the container are at least forward iterators.

容器中的迭代器至少是正向迭代器。

容器属性【Container properties】

联想的【Associative】

Elements in associative containers are referenced by their key and not by their absolute position in the container.

关联容器中的元素由其键引用，而不是由其在容器中的绝对位置引用。

无序的【Unordered】

Unordered containers organize their elements using hash tables that allow for fast access to elements by their key.

无序容器使用哈希表组织它们的元素，哈希表允许通过它们的键快速访问元素。

地图【Map】

Each element associates a key to a mapped value: Keys are meant to identify the elements whose main content is the mapped value.

每个元素都将一个键与一个映射值相关联：键用于标识主要内容为映射值的元素。

唯一键【Unique keys】

No two elements in the container can have equivalent keys.

容器中的任何两个元素都不能有相同的键。

分配器感知【Allocator-aware】

The container uses an allocator object to dynamically handle its storage needs.

容器使用分配器对象动态处理其存储需求。

成员类型【Member types】

成员函数【Member functions】

(constructor)

构造向量（公共成员函数）

实例【Example】

// constructing unordered_maps
#include <iostream>
#include <string>
#include <unordered_map>

typedef std::unordered_map<std::string,std::string> stringmap;

stringmap merge (stringmap a,stringmap b) {
  stringmap temp(a); temp.insert(b.begin(),b.end()); return temp;
}

int main ()
{
  stringmap first;                              // empty
  stringmap second ( {{"apple","red"},{"lemon","yellow"}} );       // init list
  stringmap third ( {{"orange","orange"},{"strawberry","red"}} );  // init list
  stringmap fourth (second);                    // copy
  stringmap fifth (merge(third,fourth));        // move
  stringmap sixth (fifth.begin(),fifth.end());  // range

  std::cout << "sixth contains:";
  for (auto& x: sixth) std::cout << " " << x.first << ":" << x.second;
  std::cout << std::endl;

  return 0;
}

输出【Output】

sixth contains: apple:red lemon:yellow orange:orange strawberry:red

empty (1)
explicit unordered_map ( size_type n = /* see below */,
                         const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& alloc = allocator_type() );
explicit unordered_map ( const allocator_type& alloc );

range (2)
template <class InputIterator>
  unordered_map ( InputIterator first, InputIterator last,
                  size_type n = /* see below */,
                  const hasher& hf = hasher(),
                  const key_equal& eql = key_equal(),
                  const allocator_type& alloc = allocator_type() );
  
copy (3)
unordered_map ( const unordered_map& ump );
unordered_map ( const unordered_map& ump, const allocator_type& alloc );
  
move (4)
unordered_map ( unordered_map&& ump );
unordered_map ( unordered_map&& ump, const allocator_type& alloc );
  
initializer list (5)  
unordered_map ( initializer_list<value_type> il,
                size_type n = /* see below */,
                const hasher& hf = hasher(),
                const key_equal& eql = key_equal(),
                const allocator_type& alloc = allocator_type() );