unordered_map

std::unordered_map()

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;

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

在unordered_map中，键值通常用于唯一标识元素，而映射值是具有与此键关联的内容的对象。键和映射值的类型可能不同。

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

unordered_map容器的迭代器指向此value_type的元素。因此，对于一个名为it的迭代器，它指向一个map的元素，它的键和映射值可以分别用：

unordered_map<Key,T>::iterator it;
(*it).first;             // the key value (of type Key)
(*it).second;            // the mapped value (of type T)
(*it);                   // the "element value" (of type pair<const Key,T>)

或者可以这样访问它：

it->first;               // same as (*it).first   (the key value)
it->second;              // same as (*it).second  (the mapped value)

构造函数：

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() );

关于范围构造函数：将 InputIterator迭代器指定范围[ first, last) 内值，作为参数赋给构造函数，函数模板类型可以是任何类型的输入迭代器。

例子：

#include<iostream>
#include<unordered_map>
#include<string>

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

stingmap 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"}});
    stringmap third ( {{"orange","orange"},{"strawberry","red"}} );  // init list
    stingmap fourth(second);
    stringmap fifth(merge(third,first));
    sringmap sixth(fifth.begin(),fifth.end());

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

unordered_map::at()

mapped_type& at ( const key_type& k );
const mapped_type& at ( const key_type& k ) const;

返回对unordered_map中带有键k的元素的映射值的引用。 如果k与容器中任何元素的键不匹配，则该函数抛出out_of_range异常。

例子：

// unordered_map::at
#include <iostream>
#include <string>
#include <unordered_map>

int main ()
{
  std::unordered_map<std::string,int> mymap = {
                { "Mars", 3000},
                { "Saturn", 60000},
                { "Jupiter", 70000 } };

  mymap.at("Mars") = 3396;
  mymap.at("Saturn") += 272;
  mymap.at("Jupiter") = mymap.at("Saturn") + 9638;

  for (auto& x: mymap) {
    std::cout << x.first << ": " << x.second << std::endl;
  }

  return 0;
}

unordered_map::begin（）

container iterator (1)	iterator begin() noexcept; const_iterator begin() const noexcept;
bucket iterator (2)	local_iterator begin ( size_type n ); const_local_iterator begin ( size_type n ) const;

 返回指向unordered_map容器（1）或其中一个存储桶（2）中的第一个元素的迭代器。请注意，unordered_map对象不保证哪个特定元素被视为其第一个元素。但是，在任何情况下，从开始到结束的范围都涵盖容器（或存储桶）中的所有元素，直到无效。

参数： n --桶号码。这应低于bucket_count。它是一个可选参数，用于更改此成员函数的行为：如果设置，则检索到的迭代器指向存储桶的第一个元素，否则它指向容器的第一个元素。

返回值：返回指向容器的第一个元素或者桶的第一个元素。

例子：

#include <iostream>
#include <unordered_map>
int main()
{
    std::unordered_map<std::string,std::string> mymap;
    mymap={ {""Australia","Canberra"},{"U.S.","Washington"},{"France","Paris"}};
    
    std::cout<<"mymap contains:";
    for(auto it=mymap.begin();it!=mymap.end();it++)
        {std::cout<<" "<<it->first<<" :"<<it->second;
    std::cout<<"mymap's buckets contains:";
    for(unsigned int i=0;i<mymap.bucket_count();i++){
        std::cout<<"bucket #"<<i<<"contains:";
        for(auto loacl_it=mymap.begin(i);it!=mymap.end(i);it++)
            std::cout<<" ”<<local_it->first<< ":"<<local_it->second;
        std::cout<<std::endl;
        }
    return 0;
} 

Possible output:

mymap contains: France:Paris Australia:Canberra U.S.:Washington mymap's buckets contain: bucket #0 contains: bucket #1 contains: bucket #2 contains: bucket #3 contains: bucket #4 contains: bucket #5 contains: France:Paris bucket #6 contains: bucket #7 contains: Australia:Canberra bucket #8 contains: U.S.:Washington bucket #9 contains: bucket #10 contains: