C++ unordered_map的使用

時間  2019-11-06
標籤 c++ unordered map 使用 欄目 C&C++ 简体版
原文   原文鏈接

參考：http://www.cplusplus.com/reference/unordered_map/unordered_map/?kw=unordered_mapios

std::unordered_map(C++11)

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中，鍵值一般用於唯一地標識元素，而映射的值是一個對象，其內容與此鍵相關聯。鍵和映射值的類型可能不一樣。
在內部,unordered_map中的元素沒有對鍵值或映射值以任何特定的順序排序,但組織成buckets的形式都取決於他們的散列值,以便經過它的鍵值快速訪問單個元素(平均一個恆定的平均時間複雜度)。

unordered_map容器比map容器能更快地經過它們的鍵訪問單個元素，儘管它們一般對於元素子集的範圍迭代效率較低。
無序映射實現了直接訪問操做符(operator[])，該操做符容許使用其鍵值做爲參數直接訪問映射值。
容器中的迭代器至少是前向迭代器forward iterators。算法

 

Container properties容器屬性數組

Associative關聯性
關聯容器中的元素由它們的鍵引用，而不是由它們在容器中的絕對位置引用。
Unordered無序性

無序容器使用散列表來組織它們的元素，散列表容許經過它們的鍵快速訪問元素。app

Map映射

每一個元素都將一個鍵關聯到一個映射值:鍵表示標識其主要內容爲映射值的元素。dom

Unique keys
容器中的任何兩個元素都不能具備相同的鍵。
Allocator-aware

容器使用一個分配器對象來動態地處理它的存儲需求。函數

 

Template parameters模版參數

key：性能

鍵值的類型。unordered_map中的每一個元素都由其鍵值惟一標識。
別名爲成員類型unordered_map::key_type。測試

T:優化

映射值的類型。unordered_map中的每一個元素都用於將一些數據存儲爲其映射值。
別名爲成員類型unordered_map::mapped_type。注意，這與unordered_map::value_type(參見下面)不一樣。ui

Hash:
一個一元函數對象類型，它接受一個key類型的對象做爲參數，並基於它返回一個類型size_t的惟一值。它能夠是實現函數調用操做符的類，也能夠是指向函數的指針(參見構造函數的示例)。默認值是hash<key>，它返回一個散列值，碰撞機率接近1.0/std::numeric_limits<size_t>::max()。
unordered_map對象使用此函數返回的散列值在內部組織其元素，從而加快了定位單個元素的過程。
別名爲成員類型unordered_map::hasher。
Pred:（ 判斷兩個鍵值是否相同）
一個二進制謂詞，它接受兩個鍵key類型的參數並返回一個bool。表達式pred (a, b), pred是這種類型的一個對象,a和b是鍵值,若是a應考慮至關於b則返回true。這能夠是一個實現一個函數調用操做符或指向函數的指針(見構造函數爲例)的類。這默認爲equal_to<key>，它返回的結果與應用equal-to操做符相同(a==b)。
unordered_map對象使用這個表達式來肯定兩個元素鍵是否相等。使用此謂詞，unordered_map容器中的任何兩個元素都不能具備產生true的鍵。
別名爲成員類型unordered_map::key_equal。
Alloc：
用於定義存儲分配模型的分配器對象的類型。默認狀況下，使用的是分配器類模板，它定義了最簡單的內存分配模型，而且是與值無關的。
別名爲成員類型unordered_map::allocator_type。
在unordered_map成員函數的引用中，模板參數使用相同的名稱(Key、T、Hash、Pred和Alloc)。
unordered_map容器元素的迭代器同時訪問鍵和映射值。爲此，該類定義了一個名爲value_type的類，它是一個pair類，它的第一個值對應於鍵類型的const版本(模板參數鍵)，第二個值對應於映射的值(模板參數T): 
typedef pair<const Key, T> value_type;

unordered_map容器的迭代器指向此value_type的元素。所以，對於一個指向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)

 

Member types成員類型

如下別名是unordered_map的成員類型。它們被成員函數普遍用做參數和返回類型:

成員類型 定義 notes
key_type 第一個模版參數（Key）  
mapped_type 第二個模版參數（T）  
value_type pair<const key_type,mapped_type>  
hasher 第三個模版參數（Hash） 默認爲:hash<key_type>
key_equal 第四個模版參數（Pred） 默認爲:equal_to<key_type>
allocator_type 第五個模版參數（Alloc） 默認爲:allocator<value_type>
reference Alloc::reference  
const_reference Alloc::const_reference  
pointer Alloc::pointer 默認爲allocator: value_type*
const_pointer Alloc::const_pointer 默認爲allocator: const value_type*
iterator value_type的前向迭代器  
const_iterator const value_type的前向迭代器  
local_iterator value_type的前向迭代器  
const_local_iterator const value_type的前向迭代器  
size_type 一個無符號的整數類型 等同於size_t
difference_type 一個有符號的整數類型 等同於ptrdiff_t

 

 

 

 

 

 

 

 

 

 

 

 

 

Member functions成員函數

1）構造函數

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

構建unordered_map
構造一個unordered_map容器對象，根據使用的構造函數版本初始化其內容:

(1)空容器構造函數(默認構造函數)
構造一個空的unordered_map對象，該對象不包含元素，大小爲0。
它可使用特定的hasher、key_equal和分配器對象以及最少數量的散列桶來構造容器。
(2)range構造函數
構造一個unordered_map對象，該對象包含[first,last)範圍內每一個元素的副本。
(3)複製構造函數(以及複製分配器)
對象初始化爲具備與unordered_map對象ump相同的內容和屬性。
(4)移動構造函數(以及使用分配器移動)
對象獲取rvalue右值ump的內容。
(5)初始化器列表
用列表的內容初始化容器。

 

參數：

n:

初始桶的最小數量。
這不是容器中的元素數量，而是構造內部哈希表所需的最小槽數。
若是沒有指定這個參數，構造函數將自動肯定(以一種依賴於特定庫實現的方式)。
成員類型size_type是無符號整數類型。

hf:

hasher函數對象。hasher是一個基於做爲參數傳遞給它的容器對象鍵值key而返回整數值的函數，即該整數值 = hasher(key)。
成員類型hasher在unordered_map中定義爲其第三個模板參數(Hash)的別名。

eql:

若是做爲參數傳遞的兩個容器對象鍵key被認爲是相等的，則返回true。
成員類型key_equal在unordered_map中定義爲其第四個模板參數(Pred)的別名。

alloc:

要使用的分配器對象，而不是構造新對象。
對於使用默認分配器類模板版本的類實例化，此參數不相關。
成員類型allocator_type在unordered_map中定義爲其第五個模板參數(Alloc)的別名。

first, last：
將迭代器輸入到範圍的初始和最終位置。使用的範圍是[first,last)，它包括first和last之間的全部元素，包括first指向的元素，但不包括last指向的元素。
函數模板類型能夠是任何類型的輸入迭代器。
ump:
另外一個相同類型的unordered_map對象(具備相同的類模板參數)，其內容能夠複製或移動。
il：
一個initializer_list對象。
這些對象是由初始化器列表聲明器自動構造的。
成員類型value_type是容器中元素的類型，在unordered_map中定義爲pair<const key_type,mapped_type>，其中成員類型key_type是第一個模板參數(key類型)的別名，而mapped_type是第二個模板參數(映射mapped類型，T)的別名。
舉例： 
#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

using stringmap = unordered_map<string, string>;

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

int main(){
    stringmap first;
    stringmap second {{"apple", "red"},{"lemon","yellow"}};
    stringmap third {{"orange","orange"}, {"strawberry", "red"}};
    stringmap fourth (second);
    stringmap fifth (merge(third, fourth));
    stringmap sixth (fifth.begin(), fifth.end());

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

返回：

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

 

2）析構函數

~unordered_map();

銷燬無序的映射
銷燬容器對象。這將調用所包含元素的每一個析構函數，並釋放由unordered_map容器分配的全部存儲容量。

 

3）賦值操做

copy (1)    
unordered_map& operator= ( const unordered_map& ump );

move (2)    
unordered_map& operator= ( unordered_map&& ump );

initializer list (3)    
unordered_map& operator= ( intitializer_list<value_type> il );

賦值內容
賦值ump(或il)做爲容器的新內容。

在調用以前包含在對象中的元素被銷燬，並被unordered_map ump或初始化器列表il中的元素替換(若是有的話)。
第一個版本(1)執行一個複製賦值，它將ump的全部元素複製到容器對象中(ump保留其內容)。
第二個版本(2)執行移動分配，將ump內容的全部權轉移給對象。沒有賦值發生:內容被ump丟棄。
第三個版本(3)將初始化器列表il的內容賦值爲容器對象的元素。

參數：

ump：
有着相同類型的unordered_map對象（有着相同的模版參數）
il：
一個initializer_list對象。編譯器將從初始化器列表聲明器自動構造這些對象。
成員類型value_type是unordered_map中包含的元素的類型，它是pair<const key_type,mapped_type>，其中成員類型key_type是第一個模板參數(key類型)的別名，而mapped_type是第二個模板參數(mapped映射類型，T)的別名。
返回值：
*this
舉例： 
#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

using stringmap = unordered_map<string, string>;

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

int main(){
    stringmap first, second, third;
    first = {{"AAPL","Apple"},{"MSFT","Microsoft"}}; //初始化列表
    second = {{"GOOG", "Google"}, {"ORCL", "Oracle"}};
    third = merge(first, second);
    first = third;

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

返回：

first contains :   GOOG:Google  ORCL:Oracle  MSFT:Microsoft  AAPL:Apple

 

Capacity容量

4）empty

bool empty() const noexcept;

測試容器是否爲空
返回一個bool值，該值指示unordered_map容器是否爲空，即其大小是否爲0。

此函數不以任何方式修改容器的內容。要清除數組對象的內容，成員函數unordered_map::clear是存在的。

參數：

none

返回值：

若是容器大小爲0則返回true，不然返回false

舉例：

#include <iostream>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<int, int> first;
    unordered_map<int, int> second = {{1,10},{2,20},{3,30}};
    cout << "first " << (first.empty()?"is empty":"is not empty") << endl;
    cout << "second " << (second.empty()? "is empty" : "is not empty") << endl;
    return 0;
}

返回：

first is empty
second is not empty

 

5）size

size_type size() const noexcept;

返回容器大小
返回unordered_map容器中的元素數量。

參數：

none

返回值：

容器中元素的數量。
成員類型size_type是無符號整數類型。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<string,double> mymap ={
            {"milk", 2.30},
            {"potatoes", 1.90},
            {"eggs", 0.40}
    };
    cout << "mymap.size() is " << mymap.size() << endl;
    return 0;
}

返回：

mymap.size() is 3

 

6）max_size

size_type max_size() const noexcept;

返回最大大小
返回unordered_map容器能夠容納的元素的最大數量。

這是因爲系統約束或其庫實現的限制，容器所能容納的最大潛在元素數。

參數：
none

返回值：

對象能夠做爲內容容納的元素的最大數目。
成員類型size_type是無符號整數類型。

舉例：

#include <iostream>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<int,int> mymap;
    cout << "max_size = " << mymap.max_size() << endl;
    cout << "max_bucket_count = " << mymap.max_bucket_count() << endl;
    cout << "max_load_factor = " << mymap.max_load_factor() << endl;
    return 0;
}

返回：

max_size = 768614336404564650
max_bucket_count = 768614336404564650
max_load_factor = 1

 

Iterators迭代器

7）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。
它是一個可選參數，能夠改變這個成員函數的行爲:若是設置，迭代器將檢索到該桶的第一個元素，不然它將指向容器的第一個元素。
成員類型size_type是無符號整數類型。

返回值：

容器(1)或桶(2)中的第一個元素的迭代器。

全部返回類型(iterator、const_iterator、local_iterator和const_local_iterator)都是成員類型。在unordered_map類模板中，這些是正向迭代器類型。
局部迭代器與非局部迭代器屬於同一類別。它們的value_type、diffence_type、指針和引用成員類型也是相同的。可是迭代器自己不必定是相同類型的。

 

8）end

container iterator (1)    
      iterator end() noexcept;
const_iterator end() const noexcept;

bucket iterator (2)    
      local_iterator end (size_type n);
const_local_iterator end (size_type n) const;

返回迭代器終點
返回一個迭代器，該迭代器指向unordered_map容器(1)或其中一個桶(2)中的past-the-end元素。

end返回的迭代器不指向任何元素，而是指向unordered_map容器中最後一個元素後面的位置(它的結束位置)。所以，返回的值不能取消引用——它一般用於描述一個範圍的開放端，好比[begin,end]。
注意，unordered_map對象並不保證其元素的順序。可是，在任何狀況下，從開始到結束的範圍覆蓋容器(或桶)中的全部元素，直到失效。

參數：

n:

桶數。這應該小於bucket_count。
它是一個可選參數，能夠改變這個成員函數的行爲:若是設置，迭代器將檢索到該桶的第一個元素，不然它將指向容器的第一個元素。
成員類型size_type是無符號整數類型。

返回值：

元素的迭代器，遍歷容器(1)或桶(2)的末端。

全部返回類型(iterator、const_iterator、local_iterator和const_local_iterator)都是成員類型。在unordered_map類模板中，這些是正向迭代器類型。
局部迭代器與非局部迭代器屬於同一類別。它們的value_type、diffence_type、指針和引用成員類型也是相同的。可是迭代器自己不必定是相同類型的。

 

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<string, string> mymap;
    mymap = {{"Australia", "canberra"}, {"U.S.", "Washington"}, {"France", "Paris"}};
    cout << "mymap contains : ";
    for(auto it = mymap.begin(); it!=mymap.end(); ++it)
        cout << "  " << it->first << " : " << it->second;
    cout << endl;

    cout << "mymap's buckets contains: \n";
    for(unsigned i = 0; i<mymap.bucket_count(); ++i){
        cout << "bucket #" << i << " contains : ";
        for(auto local_it = mymap.begin(i); local_it!=mymap.end(i); ++local_it)
            cout << "  " <<local_it->first << " : " << local_it->second;
        cout << endl;
    }
    return 0;
}

返回：

mymap contains :   France : Paris  U.S. : Washington  Australia : canberra
mymap's buckets contains: 
bucket #0 contains : 
bucket #1 contains : 
bucket #2 contains :   France : Paris
bucket #3 contains :   U.S. : Washington  Australia : canberra
bucket #4 contains :

 

9）cbegin

container iterator (1)    
const_iterator cbegin() const noexcept;

bucket iterator (2)    
const_local_iterator cbegin ( size_type n ) const;

返回const_iterator起點
返回一個const_iterator，指向unordered_map容器(1)或其中一個桶(2)中的第一個元素。

常量迭代器是指向const內容的迭代器。這個迭代器能夠增長或減小(除非它自己也是const)，就像unordered_map::begin返回的迭代器同樣，可是它不能用來修改它所指向的內容。

參數：

n:

桶數。這應該小於bucket_count。
它是一個可選參數，能夠改變這個成員函數的行爲:若是設置，迭代器將檢索到該桶的第一個元素，不然它將指向容器的第一個元素。
成員類型size_type是無符號整數類型。

返回值：

容器(1)或桶(2)中的第一個元素的迭代器。

 

const_iterator和const_local_iterator都是成員類型。在unordered_map類模板中，這些是正向迭代器類型。
const_local_iterator是與const_iterator相同類別的interator。它們的value_type、diffence_type、指針和引用成員類型也是相同的。可是迭代器自己不必定是相同類型的。

 

10）cend

container iterator (1)    
const_iterator cend() const noexcept;

bucket iterator (2)    
const_local_iterator cend ( size_type n ) const;

返回const_iterator結尾
返回一個const_iterator，指向unordered_map容器(1)或其中一個桶(2)中的past-the-end元素。

cend返回的const_iterator不指向任何元素，而是指向unordered_map容器中最後一個元素以後的位置（past-the-end），或者它的一個bucket(即，past-the-end的位置)。所以，返回的值不能取消引用——它一般用於描述範圍的開放端，好比[cbegin,cend)。

注意，unordered_map對象並不保證其元素的順序。可是，在任何狀況下，從cbegin到cend的範圍覆蓋容器(或bucket)中的全部元素，直到失效。

const_iterator是指向const內容的迭代器。這個迭代器能夠增長或減小(除非它自己也是const)，就像unordered_map::end返回的迭代器同樣，可是它不能用來修改它所指向的內容。

參數：

n:

桶數。這應該小於bucket_count。
它是一個可選參數，能夠改變這個成員函數的行爲:若是設置，迭代器將檢索到該桶的第一個元素，不然它將指向容器的第一個元素。
成員類型size_type是無符號整數類型。

返回值：

元素的迭代器，遍歷容器(1)或桶(2)的末端。

const_iterator和const_local_iterator都是成員類型。在unordered_map類模板中，這些是正向迭代器類型。
const_local_iterator是與const_iterator相同類別的interator。它們的value_type、diffence_type、指針和引用成員類型也是相同的。可是迭代器自己不必定是相同類型的。

 

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<string, string> mymap;
    mymap = {{"Australia", "canberra"}, {"U.S.", "Washington"}, {"France", "Paris"}};

    cout << "mymap contains : ";
    for(auto it = mymap.cbegin(); it!=mymap.cend(); ++it)
        cout << "  " << it->first << " : " << it->second;
    cout << endl;

    cout << "mymap's buckets contains: \n";
    for(unsigned i = 0; i<mymap.bucket_count(); ++i){
        cout << "bucket #" << i << " contains : ";
        for(auto local_it = mymap.cbegin(i); local_it!=mymap.cend(i); ++local_it)
            cout << "  " <<local_it->first << " : " << local_it->second;
        cout << endl;
    }
    return 0;
}

返回：

mymap contains :   France : Paris  U.S. : Washington  Australia : canberra
mymap's buckets contains: 
bucket #0 contains : 
bucket #1 contains : 
bucket #2 contains :   France : Paris
bucket #3 contains :   U.S. : Washington  Australia : canberra
bucket #4 contains :

 

Element access元素訪問

11）operator[]

mapped_type& operator[] ( const key_type& k );
mapped_type& operator[] ( key_type&& k );

訪問元素
若是k匹配容器中元素的鍵，則該函數返回對其映射值的引用。

若是k不匹配容器中任何元素的鍵，則該函數用該鍵插入一個新元素並返回對其映射值的引用。請注意，即便沒有將映射值分配給元素(元素是使用其默認構造函數構造的)，這也老是將容器大小增長1。
相似的成員函數unordered_map::at在具備鍵的元素存在時具備相同的行爲，但在元素不存在時拋出異常。

參數：

k:

要訪問其映射值的元素的鍵值。
成員類型key_type是存儲在容器中的元素的鍵的類型，在unordered_map中定義爲其第一個模板參數(鍵key)的別名。
若是是rvalue(第二個版本，右值引用)，則在插入新元素時移動鍵而不是複製鍵。

返回值：

對元素的映射值的引用，其鍵值等效於k。
成員類型mapped_type是容器中映射值的類型，在unordered_map中定義爲其第二個模板參數(T)的別名。

若是插入了新元素，則使用allocator_traits<allocator_type>::construct()分配它的存儲，這可能會在失敗時拋出異常(對於默認分配器，若是分配請求沒有成功，則拋出bad_alloc)。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;


int main(){
    unordered_map<string, string> mymap;
    mymap["Bakery"] = "Barbara";
    mymap["Seafood"] = "Lisa";
    mymap["Produce"] = "John";

    string name = mymap["Bakery"];
    mymap["Seafood"] = name;

    mymap["Bakery"] = mymap["Produce"];
    name = mymap["Deli"];

    mymap["Produce"] = mymap["Gifts"];

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

    return 0;
}

返回：

Deli: 
Produce: 
Gifts: 
Seafood: Barbara
Bakery: John

 

12)at

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

訪問元素
返回對unordered_map中鍵爲k的元素的映射值的引用。
若是k不匹配容器中任何元素的鍵，該函數將拋出out_of_range異常。

參數：

k:

要訪問其映射值的元素的鍵值。
成員類型key_type是存儲在容器中的元素的鍵的類型，在unordered_map中定義爲其第一個模板參數(鍵key)的別名。

返回值：

對元素的映射值的引用，其鍵值等效於k。
成員類型mapped_type是容器中映射值的類型，在unordered_map中定義爲其第二個模板參數(T)的別名。

 

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<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){
        cout << x.first << ": " << x.second << endl;
    }
    return 0;
}

返回：

Jupiter: 69910
Saturn: 60272
Mars: 3396

 

Element lookup元素查看

13）find

iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const;

獲取元素的iterator
在容器中搜索以k爲鍵的元素，若是找到了，就返回一個迭代器，不然就返回unordered_map::end(容器末尾的元素)的迭代器。

另外一個成員函數unordered_map::count可用於檢查特定鍵是否存在。
還可使用at或操做符[]的成員函數直接訪問映射值。

參數：

k:

要搜索的建值key。
成員類型key_type是容器中元素的鍵的類型，在unordered_map中定義爲其第一個模板參數(key鍵)的別名。

返回值：

元素的迭代器(若是找到指定的鍵值)，或者unordered_map::end(若是在容器中沒有找到指定的鍵)。
成員類型iterator和const_iterator是前向迭代器類型。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;


int main(){
    unordered_map<string, double> mymap = {
            {"mom", 5.4},
            {"dad", 6.1},
            {"bro", 5.9}
    };
    string input;
    cout << "who?";
    getline(cin, input);
    unordered_map<string, double>::const_iterator got = mymap.find(input);

    if(got == mymap.end())
        cout << "not found";
    else
        cout << got->first << " is " << got->second;
    cout << endl;
    return 0;
}

返回：

who?mom
mom is 5.4

 

14）count

size_type count ( const key_type& k ) const;

用特定的鍵對元素計數
在容器中搜索鍵爲k的元素，並返回找到的元素數量。由於unordered_map容器不容許重複的鍵，這意味着若是容器中存在具備該鍵的元素，則該函數實際返回1，不然返回0。

參數：

k:

要搜索的建值key。
成員類型key_type是容器中元素的鍵的類型，在unordered_map中定義爲其第一個模板參數(key鍵)的別名。

返回值：

若是找到鍵值等於k的元素，則爲1，不然爲0。

成員類型size_type是無符號整數類型。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<string, double> mymap = {
            {"Burger", 2.99},
            {"Fries", 1.99},
            {"Soda", 1.50}
    };

    for(auto& x : {"Burger", "Pizza", "Salad", "Soda"}){
        if(mymap.count(x) > 0){
            cout << "mymap has " << x << endl;
        }else{
            cout << "mymap has no " << x << endl;
        }
    }
    return 0;
}

返回：

mymap has Burger
mymap has no Pizza
mymap has no Salad
mymap has Soda

 

15）equal_range

pair<iterator,iterator>
   equal_range ( const key_type& k );
pair<const_iterator,const_iterator>
   equal_range ( const key_type& k ) const;

獲取具備特定鍵值的元素範圍
返回一個範圍的邊界，該範圍包含容器中全部的元素，其中鍵的值與k相比較。在unordered_map容器中，鍵是唯一的，該範圍最多包含一個元素。

若是k與容器中的任何鍵不匹配，則返回的範圍將end做爲其上下範圍邊界。

參數：

k:

要搜索的建值key。
成員類型key_type是容器中元素的鍵的類型，在unordered_map中定義爲其第一個模板參數(key鍵)的別名。

返回值：

函數返回一個對pair，其中它的成員pair::first是指向範圍下界的迭代器，pair::second是指向其上界的迭代器。範圍內的元素是這兩個迭代器之間的元素，包括pair::first，而不包括pair::second。

成員類型iterator和const_iterator是前向迭代器類型。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

using stringmap = unordered_map<string, string>;


int main(){
    stringmap myumm = {
            {"orange", "FL"},
            {"strawberry", "LA"},
            {"strawberry", "OK"},
            {"pumpkin", "NH"}
    };
    cout << "Entries with strawberry : ";
    auto range = myumm.equal_range("strawberry");
    for_each(
            range.first,
            range.second,
            [](stringmap::value_type& x){cout << " " << x.second;}
            );
    return 0;
}

返回：

Entries with strawberry :  LA

若是使用的是unordered_multimap：

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

using stringmap = unordered_multimap<string, string>;

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

int main(){
    stringmap myumm = {
            {"orange", "FL"},
            {"strawberry", "LA"},
            {"strawberry", "OK"},
            {"pumpkin", "NH"}
    };
    cout << "Entries with strawberry : ";
    auto range = myumm.equal_range("strawberry");
    for_each(
            range.first,
            range.second,
            [](stringmap::value_type& x){cout << " " << x.second;}
            );
    return 0;
}

返回：

Entries with strawberry :  LA OK

 

Modifiers修改

16）emplace-若是該建值已有則不操做

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

構造和插入元素
若是unordered_map的鍵是唯一的，則在該元素中插入一個新元素。使用args做爲元素構造函數的參數構造這個新元素。

只有在容器中沒有與被放置的鍵等價的鍵時才進行插入(unordered_map中的鍵是唯一的)。

若是插入，這將有效地將容器大小增長1。
存在一個相似的成員函數insert，它複製或將現有對象移動到容器中。

參數：

args：

參數，用於爲插入的元素構造映射類型的新對象。

返回值：

若是發生插入的狀況(由於不存在具備相同鍵值的其餘元素)，函數將返回一個pair對象，該對象的第一個組件是插入元素的迭代器，第二個組件爲true。

不然，返回的pair對象的第一個組件是一個迭代器，它指向容器中具備相同鍵的元素，第二個組件是false。
成員類型迭代器是正向迭代器類型。

新元素的存儲是使用allocator_traits<allocator_type>::construct()分配的，它可能會在失敗時拋出異常(對於默認的分配器，若是分配請求沒有成功，就會拋出bad_alloc)。

 

17）emplace_hint

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

使用提示來構造和插入元素
若是unordered_map的鍵是唯一的，則在該元素中插入一個新元素。使用args做爲元素構造函數的參數構造這個新元素。position位置點指向容器中的一個位置，該位置提示從何處開始搜索其插入點(容器可能使用，也可能不使用此建議來優化插入操做)。

只有在容器中沒有與被放置的鍵等價的鍵時才進行插入(unordered_map中的鍵是唯一的)。
若是插入，這將有效地將容器大小增長1。

相似的成員函數insert也存在，它能夠複製或將現有對象移動到容器中，也能夠獲取位置提示。

參數：

position：

做爲插入操做提示的位置。容器可使用這個值來優化操做。
成員類型const_iterator是正向迭代器類型。

args：

參數，用於爲插入的元素構造映射類型的新對象。

返回值：

容器中元素的迭代器，其鍵至關於新插入的元素。若是確實插入了新插入的元素，那麼它將指向該元素;若是已經存在鍵，則指向具備等效鍵的現有元素(不替換它)。

成員類型迭代器是一個前向迭代器。
新元素的存儲是使用allocator_traits<allocator_type>::construct()分配的，它可能會在失敗時拋出異常(對於默認的分配器，若是分配請求沒有成功，就會拋出bad_alloc)。

 

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

int main(){
    unordered_map<string,string> mymap;
    mymap.emplace("NCC-1701", "J.T. Kirk");
    mymap.emplace("NCC-1701-D", "J.L. Picard");
    mymap.emplace("NCC-74656", "K. Janeway");
    mymap.emplace("NCC-1701", "new J.T. Kirk");

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

返回：

NCC-74656: K. Janeway
NCC-1701-D: J.L. Picard
NCC-1701: J.T. Kirk

 

18）insert-可同時插入多個

(1)    
pair<iterator,bool> insert ( const value_type& val );

(2)    
template <class P>
    pair<iterator,bool> insert ( P&& val );

(3)    
iterator insert ( const_iterator hint, const value_type& val );

(4)    
template <class P>
    iterator insert ( const_iterator hint, P&& val );

(5)    
template <class InputIterator>
    void insert ( InputIterator first, InputIterator last );

(6)    
void insert ( initializer_list<value_type> il );

插入元素
在unordered_map中插入新元素。

只有當每一個元素的鍵不等於容器中已經存在的任何其餘元素的鍵時，纔會插入元素(unordered_map中的鍵是唯一的)。
這實際上增長了插入元素的數量，從而增長了容器的大小。
這些參數決定了插入了多少個元素，並將它們初始化爲哪些值:

參數：

val：
對象複製到新元素的值(或做爲新元素的值移動)。
版本(1)和(3)複製元素(即val保存它的內容，容器保存一個副本)。
版本(2)和(4)移動元素(即 val將丟失它的內容，它將被容器中的新元素獲取)。
成員類型value_type是容器中元素的類型，在unordered_map中定義爲對<const key_type,mapped_type>，其中成員類型key_type是第一個模板參數(key類型)的別名，而mapped_type是第二個模板參數(mapped映射類型，T)的別名。
只有當P是隱式轉換爲value_type的類型時，才調用帶有P&&類型參數的簽名。
hint：
迭代器到建議的位置，做爲從何處開始搜索合適的插入點的提示。容器可能使用這個值，也可能不使用它來優化操做。元素將存儲在其相應的bucket中，而無論做爲提示傳遞的是什麼。

成員類型const_iterator是正向迭代器類型。

first, last：
指定元素範圍的迭代器。將[first,last)範圍內的元素的副本插入到unordered_map容器中。
注意，範圍包括first和last之間的全部元素，包括first指向的元素，但不包括last指向的元素。
第一個和最後一個都不是目標容器中的迭代器。
模板類型能夠是任何類型的輸入迭代器。
il:
一個initializer_list對象。編譯器將從初始化器列表聲明器自動構造這些對象。
成員類型value_type容器中包含的元素的類型,定義在unordered_map一pair< key_type const, mapped_type >,成員類型相關聯是一個別名的第一個模板參數(key鍵類型),和mapped_type別名的第二個模板參數(mapped映射類型,T)。
返回值：
在版本(1)和(2)中，函數返回一個pair對象，該對象的第一個元素是一個迭代器，它指向容器中新插入的元素或鍵值相等的元素，並返回一個bool值，該值指示元素是否被成功插入。
在版本(3)和(4)中，函數返回一個迭代器，它要麼指向容器中新插入的元素，要麼指向鍵相同的元素。
版本(5)和(6)沒有返回任何值。
成員類型迭代器是正向迭代器類型。

新元素的存儲是使用allocator_traits<allocator_type>::construct()分配的，它可能會在失敗時拋出異常(對於默認的分配器，若是分配請求沒有成功，就會拋出bad_alloc)。
舉例： 
#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

int main(){
    unordered_map<string, double>
            myrecipe,
            mypantry = {{"milk", 2.0}, {"flour", 1.5}};
    pair<string, double> myshopping("barking powder", 0.3);

    myrecipe.insert(myshopping);
    myrecipe.insert(make_pair<string, double>("egg", 6.0));
    myrecipe.insert({{"suger", 0.8},{"salt", 0.1}});

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

返回：

myrecipe contains : 
suger  0.8
egg  6
salt  0.1
barking powder  0.3

 

19）erase

by position (1)    
iterator erase ( const_iterator position );
by key (2)    
size_type erase ( const key_type& k );
range (3)    
iterator erase ( const_iterator first, const_iterator last );

刪除元素
從unordered_map容器中刪除單個元素或一組元素([first,last])。

經過調用每一個元素的析構函數，能夠經過刪除的元素數量有效地減小容器的大小。

參數：

position：

指向要從unordered_map中刪除的單個元素的迭代器。
成員類型const_iterator是正向迭代器類型。

k:

要刪除的建值key。
成員類型key_type是容器中元素的鍵的類型，在unordered_map中定義爲其第一個模板參數(key鍵)的別名。

first, last：
迭代器在unordered_map容器中指定要刪除的範圍:[first,last)。即範圍包括first和last之間的全部元素，包括first指向的元素，但不包括last指向的元素。
注意，unordered_map容器並不遵循任何特定的順序來組織它的元素， 所以range刪除的效果可能不太容易預測。
成員類型const_iterator是正向迭代器類型。
返回值：
版本(1)和(3)返回一個迭代器，指向被擦除的最後一個元素以後的位置。
Version(2)返回被擦除的元素的數量，在unordered_map容器中(具備唯一鍵)，若是存在鍵值爲k的元素(所以隨後被擦除)，則爲1，不然爲0。

成員類型迭代器是正向迭代器類型。
成員類型size_type是無符號整數類型。
舉例： 
#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

int main(){
    unordered_map<string, string> mymap;
    // populating container:
    mymap["U.S."] = "Washington";
    mymap["U.K."] = "London";
    mymap["France"] = "Paris";
    mymap["Russia"] = "Moscow";
    mymap["China"] = "Beijing";
    mymap["Germany"] = "Berlin";
    mymap["Japan"] = "Tokyo";
    for(auto& x:mymap)
        cout << x.first << "  " << x.second << endl;
    cout << endl;
    
    mymap.erase(mymap.begin());
    for(auto& x:mymap)
        cout << x.first << "  " << x.second << endl;
    cout << endl;

    mymap.erase("France");
    for(auto& x:mymap)
        cout << x.first << "  " << x.second << endl;
    cout << endl;

    mymap.erase(mymap.find("U.S."), mymap.end());

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

返回：

/Users/user/CLionProjects/untitled/cmake-build-debug/untitled
Japan  Tokyo
China  Beijing
U.S.  Washington
Russia  Moscow
Germany  Berlin
France  Paris
U.K.  London

China  Beijing
U.S.  Washington
Russia  Moscow
Germany  Berlin
France  Paris
U.K.  London

China  Beijing
U.S.  Washington
Russia  Moscow
Germany  Berlin
U.K.  London

China  Beijing


Process finished with exit code 0

 

20）clear

void clear() noexcept;

清除內容
將刪除unordered_map容器中的全部元素:調用它們的析構函數，並從容器中刪除它們，使其大小爲0。

參數：

none

返回值：
none

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;


int main(){
    unordered_map<string,string> mymap =
            { {"house","maison"}, {"car","voiture"}, {"grapefruit","pamplemousse"} };
    cout << "mymap contains : ";
    for(auto& x : mymap) cout << "  " << x.first << "=" << x.second;
    cout << endl;

    mymap.clear();
    mymap["hello"]="bonjour";
    mymap["sun"]="soleil";

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

返回：

mymap contains :   grapefruit=pamplemousse  car=voiture  house=maison
mymap contains :   sun=soleil  hello=bonjour

 

21）swap

void swap ( unordered_map& ump );

交換內容
經過ump的內容交換容器的內容，ump是另外一個包含相同類型元素的unordered_map對象。大小可能不一樣。

在調用這個成員函數以後，這個容器中的元素是在調用以前在ump中的元素，而ump中的元素是在這個容器中的元素。容器內部保存的其餘對象(例如它們的hasher或key_equal對象)也被交換。

該函數在容器之間交換指向數據的內部指針，而不實際執行任何副本或對單個元素進行移動，所以不管大小，執行時間都是恆定的。
注意，全局算法函數的名稱是swap。爲使unordered_map類型的參數具備與此成員函數相同的行爲和複雜性，將重載此全局函數。

參數：

ump：

另外一個與此類型相同的unordered_map容器對象。

返回值：

none

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;


int main(){
    unordered_map<std::string,std::string>
            first = {{"Star Wars","G. Lucas"},{"Alien","R. Scott"},{"Terminator","J. Cameron"}},
            second  = {{"Inception","C. Nolan"},{"Donnie Darko","R. Kelly"}};
    cout << "first contains : ";
    for(auto& x : first) cout << "  " << x.first << "=" << x.second;
    cout << endl;

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

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

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

返回：

first contains :   Terminator=J. Cameron  Alien=R. Scott  Star Wars=G. Lucas
second contains :   Donnie Darko=R. Kelly  Inception=C. Nolan
first contains :   Donnie Darko=R. Kelly  Inception=C. Nolan
second contains :   Terminator=J. Cameron  Alien=R. Scott  Star Wars=G. Lucas

 

Buckets桶

22）bucket_count

size_type bucket_count() const noexcept;

桶數
返回unordered_map容器中的桶數。

bucket是容器內部哈希表中的一個槽，根據鍵的哈希值將元素賦給它。
桶的數量直接影響容器的哈希表的負載因子(從而影響碰撞的機率)。容器會自動增長桶的數量，以使負載因子低於特定的閾值(其max_load_factor)，從而在每次須要增長桶的數量時從新散列。

參數：

none

返回值：

當前桶的數量。

成員類型size_type是無符號整數類型。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

using stringmap = unordered_map<string, string>;

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

int main(){
    unordered_map<string,string> mymap = {
            {"house","maison"},
            {"apple","pomme"},
            {"tree","arbre"},
            {"book","livre"},
            {"door","porte"},
            {"grapefruit","pamplemousse"}
    };

    unsigned n = mymap.bucket_count();

    std::cout << "mymap has " << n << " buckets.\n";

    for (unsigned i=0; i<n; ++i) {
        cout << "bucket #" << i << " contains: ";
        for (auto it = mymap.begin(i); it!=mymap.end(i); ++it)
            cout << "[" << it->first << ":" << it->second << "] ";
        cout << "\n";
    }
    return 0;
}

返回：

/Users/user/CLionProjects/untitled/cmake-build-debug/untitled
mymap has 11 buckets.
bucket #0 contains: 
bucket #1 contains: [house:maison] 
bucket #2 contains: 
bucket #3 contains: [tree:arbre] 
bucket #4 contains: 
bucket #5 contains: 
bucket #6 contains: [grapefruit:pamplemousse] [door:porte] 
bucket #7 contains: 
bucket #8 contains: 
bucket #9 contains: 
bucket #10 contains: [apple:pomme] [book:livre] 

Process finished with exit code 0

 

23）max_bucket_count

size_type max_bucket_count() const noexcept;

返回最大桶數
返回unordered_map容器能夠擁有的最大桶數。

這是因爲系統約束或其庫實現的限制，容器可能擁有的最大桶數。

參數：

none

返回值：

最大桶數。

成員類型size_type是無符號整數類型。

舉例：

#include <iostream>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<int,int> mymap;

    cout << "max_size = " << mymap.max_size() << endl;
    cout << "max_bucket_count = " << mymap.max_bucket_count() << endl;
    cout << "max_load_factor = " << mymap.max_load_factor() << endl;
    return 0;
}

返回：

max_size = 768614336404564650
max_bucket_count = 768614336404564650
max_load_factor = 1

 

24）bucket_size

size_type bucket_size ( size_type n ) const;

返回桶大小
返回bucket n中元素的數量。

bucket是容器內部哈希表中的一個槽，根據鍵的哈希值將元素賦給它。

桶中元素的數量影響訪問桶中特定元素所需的時間。容器會自動增長桶的數量，以使裝載因子(即平均桶大小)低於其max_load_factor。

參數：

n:

桶數。
這應該低於bucket_count。
成員類型size_type是無符號整數類型。

返回值：

桶中元素的數目n。

成員類型size_type是無符號整數類型。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

int main(){
    unordered_map<string,string> mymap = {
            {"us","United States"},
            {"uk","United Kingdom"},
            {"fr","France"},
            {"de","Germany"}
    };
    unsigned nbuckets = mymap.bucket_count();
    cout << "mymap has " << nbuckets << " buckets : " << endl;

    for(unsigned i = 0; i<nbuckets; ++i)
        cout << "bucket # " << i << " has " << mymap.bucket_size(i) << " elements " << endl;
    return 0;
}

返回：

mymap has 5 buckets : 
bucket # 0 has 1 elements 
bucket # 1 has 0 elements 
bucket # 2 has 0 elements 
bucket # 3 has 1 elements 
bucket # 4 has 2 elements

 

25）bucket

size_type bucket ( const key_type& k ) const;

定位元素的桶
返回鍵爲k的元素所在的桶號。

bucket是容器內部哈希表中的一個槽，根據鍵的哈希值將元素賦給它。桶的編號從0到(bucket_count-1)。
能夠經過unordered_map::begin和unordered_map::end返回的範圍迭代器訪問bucket中的各個元素。

參數：

k：

要定位其存儲桶的鍵值key。
成員類型key_type是容器中元素的鍵的類型，在unordered_map中定義爲其第一個模板參數(key鍵)的別名。

返回值：

對應k的桶序列號

成員類型size_type是無符號整數類型。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;


int main(){
    unordered_map<string,string> mymap = {
            {"us","United States"},
            {"uk","United Kingdom"},
            {"fr","France"},
            {"de","Germany"}
    };

    for (auto& x: mymap) {
        cout << "Element [" << x.first << ":" << x.second << "]";
        cout << " is in bucket #" << mymap.bucket (x.first) << endl;
    }
    return 0;
}

返回：

Element [de:Germany] is in bucket #0
Element [fr:France] is in bucket #3
Element [uk:United Kingdom] is in bucket #4
Element [us:United States] is in bucket #4

 

Hash policy

26) load_factor

float load_factor() const noexcept;

返回負載因子
返回unordered_map容器中的當前負載因子。

負載因子是容器中元素的數量(其大小)與桶的數量(bucket_count)之間的比率:
load_factor = size / bucket_count

在哈希表中，負載因素影響碰撞的機率（即兩個元素位於同一桶中的機率)。容器會自動增長桶的數量，以將負載因子保持在特定的閾值(其max_load_factor)之下，從而在每次須要擴展時致使從新散列。
要檢索或更改此閾值，請使用成員函數max_load_factor。

參數：

none

返回值：

當前的負載因子

舉例：

#include <iostream>
#include <string> #include <unordered_map> using namespace std; int main(){ unordered_map<string,string> mymap = { {"us","United States"}, {"uk","United Kingdom"}, {"fr","France"}, {"de","Germany"} }; cout << "size = " << mymap.size() << endl; cout << "bucket_count = " << mymap.bucket_count() << endl; cout << "load_factor = " << mymap.load_factor() << endl; cout << "max_load_factor = " << mymap.max_load_factor() << endl; return 0; }

返回：

size = 4 bucket_count = 5 load_factor = 0.8 max_load_factor = 1

 

27）max_load_factor

get (1)    
float max_load_factor() const noexcept;
set (2)    
void max_load_factor ( float z );

獲取或設置最大負載因子
第一個版本(1)返回unordered_map容器的當前最大負載因子。
第二個版本(2)將z設置爲unordered_map容器的新最大負載因子。

負載因子是容器中元素的數量(其大小)與桶的數量(bucket_count)之間的比率。

默認狀況下，unordered_map容器的max_load_factor爲1.0。

在哈希表中，負載因素影響碰撞的機率。，兩個元素位於同一桶中的機率)。容器使用max_load_factor的值做爲閾值，該閾值強制增長桶的數量(從而致使從新散列)。
可是請注意，該實現可能會對桶的數量施加上限(請參閱max_bucket_count)，這可能會迫使容器忽略max_load_factor。

參數：

z：

新的最大負載因子

返回值：

當前的負載因子（僅對第一個get版本）

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<string,string> mymap = {
            {"Au","gold"},
            {"Ag","Silver"},
            {"Cu","Copper"},
            {"Pt","Platinum"}
    };

    cout << "current max_load_factor: " << mymap.max_load_factor() << endl;
    cout << "current size: " << mymap.size() << endl;
    cout << "current bucket_count: " << mymap.bucket_count() << endl;
    cout << "current load_factor: " << mymap.load_factor() << endl;

    float z = mymap.max_load_factor();
    mymap.max_load_factor ( z / 2.0 ); //小於當前的負載因子則設爲當前的，即爲0.8,而不是0.5
    cout << "[max_load_factor halved]" << endl;

    cout << endl;
    cout << "new max_load_factor: " << mymap.max_load_factor() << endl;
    cout << "new size: " << mymap.size() << endl;
    cout << "new bucket_count: " << mymap.bucket_count() << endl;
    cout << "new load_factor: " << mymap.load_factor() << endl;

    mymap.max_load_factor ( 0.9 );
    cout << endl;
    cout << "new max_load_factor: " << mymap.max_load_factor() << endl;
    cout << "new size: " << mymap.size() << endl;
    cout << "new bucket_count: " << mymap.bucket_count() << endl;
    cout << "new load_factor: " << mymap.load_factor() << endl;

    return 0;
}

返回：

/Users/user/CLionProjects/untitled/cmake-build-debug/untitled
current max_load_factor: 1
current size: 4
current bucket_count: 5
current load_factor: 0.8
[max_load_factor halved]

new max_load_factor: 0.8
new size: 4
new bucket_count: 5
new load_factor: 0.8

new max_load_factor: 0.9
new size: 4
new bucket_count: 5
new load_factor: 0.8

Process finished with exit code 0

 

28）rehash

void rehash( size_type n );

設置桶數
將容器中的桶數設置爲n或更多。

若是n大於容器中當前桶的數量(bucket_count)，則強制從新散列。新的bucket count能夠等於或大於n。
若是n小於容器中桶的當前數量(bucket_count)，則該函數可能對桶數沒有影響，也可能不會強制從新散列。

rehash是對哈希表的重構:容器中的全部元素根據它們的哈希值從新排列到新的bucket集合中。這可能會改變容器內元素迭代的順序。

每當容器的負載因子在操做中超過max_load_factor時，容器就會自動執行重列。

注意，這個函數的參數是桶的數量。存在一個相似的函數unordered_map::reserve，它指望容器中的元素數量做爲參數。

參數：

n：

容器哈希表的最小桶數。
成員類型size_type是無符號整數類型。

返回值：

none

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;


int main(){
    unordered_map<string,string> mymap;
    cout << "current bucket_count: " << mymap.bucket_count() << endl;

    mymap.rehash(20);

    mymap["house"] = "maison";
    mymap["apple"] = "pomme";
    mymap["tree"] = "arbre";
    mymap["book"] = "livre";
    mymap["door"] = "porte";
    mymap["grapefruit"] = "pamplemousse";

    cout << "current bucket_count: " << mymap.bucket_count() << endl;

    return 0;
}

返回：

current bucket_count: 0
current bucket_count: 23 //結果可能大於或等於20

 

29）reserve

void reserve ( size_type n );

請求更改每一個桶的容量
將容器中的桶數(bucket_count)設置爲最適合包含至少n個元素。

若是n大於當前的bucket_count乘以max_load_factor，則容器的bucket_count將增長，並強制從新散列。
若是n小於這個值，函數可能沒有做用。

參數：

n:

所要求的元素數量爲最小容量。
成員類型size_type是無符號整數類型

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

int main(){
    unordered_map<string,string> mymap;
    mymap["house"] = "maison";
    mymap["apple"] = "pomme";
    mymap["tree"] = "arbre";
    mymap["book"] = "livre";
    mymap["door"] = "porte";
    mymap["grapefruit"] = "pamplemousse";

    cout << "current bucket_count: " << mymap.bucket_count() << endl;
    cout << "current max_load_factor: " << mymap.max_load_factor() << endl;
    for(unsigned i = 0; i<mymap.bucket_count(); ++i)
        cout << "current bucket_size: " << mymap.bucket_size(i) << endl;

    mymap.reserve(6); //n小於bucket_count*max_load_factor時
    for (auto& x: mymap) {
        std::cout << x.first << ": " << x.second << std::endl;
    }
    cout << "current bucket_count: " << mymap.bucket_count() << endl;
    cout << "current max_load_factor: " << mymap.max_load_factor() << endl;
    for(unsigned i = 0; i<mymap.bucket_count(); ++i)
        cout << "current bucket_size: " << mymap.bucket_size(i) << endl;

    mymap.reserve(15);//n大於bucket_count*max_load_factor時
    for (auto& x: mymap) {
        std::cout << x.first << ": " << x.second << std::endl;
    }
    cout << "current bucket_count: " << mymap.bucket_count() << endl;
    cout << "current max_load_factor: " << mymap.max_load_factor() << endl;
    for(unsigned i = 0; i<mymap.bucket_count(); ++i)
        cout << "current bucket_size: " << mymap.bucket_size(i) << endl;

    return 0;
}

返回：

/Users/user/CLionProjects/untitled/cmake-build-debug/untitled
current bucket_count: 11
current max_load_factor: 1
current bucket_size: 0
current bucket_size: 1
current bucket_size: 0
current bucket_size: 1
current bucket_size: 0
current bucket_size: 0
current bucket_size: 2
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 2
apple: pomme
book: livre
tree: arbre
house: maison
grapefruit: pamplemousse
door: porte
current bucket_count: 7
current max_load_factor: 1
current bucket_size: 0
current bucket_size: 1
current bucket_size: 1
current bucket_size: 2
current bucket_size: 0
current bucket_size: 1
current bucket_size: 1
apple: pomme
grapefruit: pamplemousse
book: livre
tree: arbre
house: maison
door: porte
current bucket_count: 17
current max_load_factor: 1
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 2
current bucket_size: 2
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 0
current bucket_size: 1
current bucket_size: 1

Process finished with exit code 0

經過使用unordered_map容器的指望大小(=6)來調用reserve，咱們避免了容器大小的增長可能產生的屢次重複哈希，並優化了哈希表的大小。

 

Observers

30）hash_function

hasher hash_function() const;

獲得哈希函數
返回unordered_map容器使用的散列函數對象。

散列函數是一個一元函數，它接受類型爲key_type的對象做爲參數，並基於它返回類型爲size_t的唯一值。它被構造中的容器所採用(有關更多信息，請參見unordered_map的構造函數unordered_map's constructor)。默認狀況下，它是對應鍵類型的默認哈希函數:hash<key_type>。

參數：

none

返回值：

哈希函數。

成員類型hasher是容器使用的散列函數的類型，在unordered_map中定義爲其第三個模板參數(Hash散列)的別名。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

using stringmap = unordered_map<string, string>;

int main(){
    stringmap mymap;

    stringmap::hasher fn = mymap.hash_function();

    //  使用該hash函數求hash值
    cout << "this: " << fn ("this") << endl;
    cout << "thin: " << fn ("thin") << endl;
    return 0;
}

返回：

this: 1610705967341725939
thin: 3142588895646935236

 

31）key_eq

key_equal key_eq() const;

獲得鍵等價謂詞
返回unordered_map容器使用的鍵等價比較謂詞。

鍵等價比較是一個謂詞，它接受鍵類型的兩個參數，並返回一個bool值，該值指示是否定爲它們是等價的。它被構造中的容器所採用(有關更多信息，請參見unordered_map的構造函數)。默認狀況下，它是equal_to<key_type>，返回的結果與將equal-to操做符(==)應用於參數相同。

參數：

none

返回值：

鍵相等比較對象。

成員類型key_equal是容器使用的鍵相等比較謂詞的類型，在unordered_map中定義爲其第四個模板參數(Pred)的別名。

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main(){
    unordered_map<string,string> mymap;

    bool case_insensitive = mymap.key_eq()("test","TEST");

    //判斷是否大小寫敏感
    cout << "mymap.key_eq() is ";
    cout << ( case_insensitive ? "case insensitive" : "case sensitive" );
    cout << endl;
    return 0;
}

返回：

mymap.key_eq() is case sensitive

可見是大小寫敏感的，說明返回的是false

 

32）get_allocator

allocator_type get_allocator() const noexcept;

獲得分配器
返回用於構造容器的分配器對象。

參數：

none

返回值：
分配器。

成員類型allocator_type是容器使用的分配器的類型，在unordered_map中定義爲其第五個模板參數(Alloc)的別名。

 

Non-member function overloads

33）operators

equality (1)    
template <class Key, class T, class Hash, class Pred, class Alloc>
  bool operator== ( const unordered_map<Key,T,Hash,Pred,Alloc>& lhs,
                    const unordered_map<Key,T,Hash,Pred,Alloc>& rhs );
inequality (2)    
template <class Key, class T, class Hash, class Pred, class Alloc>
  bool operator!= ( const unordered_map<Key,T,Hash,Pred,Alloc>& lhs,
                    const unordered_map<Key,T,Hash,Pred,Alloc>& rhs );

unordered_map的關係運算符
這些重載的全局操做符函數在unordered_map容器lhs和rhs之間執行適當的相等或不等比較操做。

平等比較的程序以下(若是程序找到一個結論性的答案，則在任何點中止):
首先，比較大小。
而後，在一個容器中查找另外一個容器中的每一個鍵，若是找到了，就比較它們的值。

注意，unordered_map::hash_function和unordered_map::key_eq對象在lhs和rhs中具備相同的行爲。

參數：

lhs, rhs：
unordered_map容器(分別位於操做符的左側和右側)，具備相同的模板參數(Key、T、Hash、Pred和Alloc)。
返回值：
相等則返回true，不然爲false

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

using stringmap = unordered_map<string, string>;

int main(){
    stringmap a = { {"AAPL","Apple"}, {"MSFT","Microsoft"}, {"GOOG","Google"} };
    stringmap b = { {"MSFT","Microsoft"}, {"GOOG","Google"}, {"AAPL","Apple"} };
    stringmap c = { {"MSFT","Microsoft Corp."}, {"GOOG","Google Inc."}, {"AAPL","Apple Inc."} };

    if (a==b) cout << "a and b are equal\n";
    if (b!=c) cout << "b and c are not equal\n";
    return 0;
}

返回：

a and b are equal
b and c are not equal

 

34）swap

template <class Key, class T, class Hash, class Pred, class Alloc>
  void swap ( unordered_map<Key,T,Hash,Pred,Alloc>& lhs,
              unordered_map<Key,T,Hash,Pred,Alloc>& rhs );

交換兩個unordered_map容器的內容
容器lhs的內容與rhs的內容進行交換。兩個容器對象必須具備相同的類型(相同的模板參數)，儘管大小可能不一樣。

調用這個函數以後，lhs中的元素是調用以前在rhs中的元素，rhs中的元素是在lhs中的元素。容器內部保存的其餘對象(例如它們的hasher或key_equal對象)也被交換。

這是通用算法swap的一種特殊化，它經過交換內部的數據指針來提升性能，而不須要對單個元素執行任何複製或移動。

參數：

lhs, rhs：
unordered_map容器(分別位於操做符的左側和右側)，具備相同的模板參數(Key、T、Hash、Pred和Alloc)。
返回值：
none

舉例：

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

using stringmap = unordered_map<string, string>;

int main(){
    stringmap
        first = {{"Star Wars","G. Lucas"},{"Alien","R. Scott"},{"Terminator","J. Cameron"}},
        second  = {{"Inception","C. Nolan"},{"Donnie Darko","R. Kelly"}};
    cout << "first: ";
    for (auto& x: first) cout << x.first << " (" << x.second << "), ";
    cout << endl;

    cout << "second: ";
    for (auto& x: second) cout << x.first << " (" << x.second << "), ";
    cout << endl;

    swap(first,second);

    cout << "first: ";
    for (auto& x: first) cout << x.first << " (" << x.second << "), ";
    cout << endl;

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

返回：

first: Terminator (J. Cameron), Alien (R. Scott), Star Wars (G. Lucas), 
second: Donnie Darko (R. Kelly), Inception (C. Nolan), 
first: Donnie Darko (R. Kelly), Inception (C. Nolan), 
second: Terminator (J. Cameron), Alien (R. Scott), Star Wars (G. Lucas),
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程