閱讀英文

共用方式為


hash_map 類別

注意

這個 API 已過時。 替代方法是 unordered_map Class

從集合中快速儲存和擷取資料,其中每個項目為具有已排序索引鍵 (其值唯一) 和相關聯資料值的配對。

語法

template <class Key,
    class Type,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<pair <const Key, Type>>>
class hash_map

參數

Key
要儲存在中的 hash_map索引鍵數據類型。

Type
要存放在 hash_map 中的項目資料類型。

Traits
包含兩個函式物件的型別,其中一個類別比較能夠比較兩個元素值做為排序索引鍵,以判斷其相對順序和哈希函式,該函式是一元述詞,會將元素的索引鍵值對應至類型 size_t不帶正負號的整數。 這個自變數是選擇性的,而且 hash_compare<Key, less<Key>> 是預設值。

Allocator
型別,表示預存配置器物件,該物件會封裝記憶體配置和解除分配的詳細 hash_map數據。 這個引數是選用引數,且預設值是 allocator<pair <const Key, Type>>

備註

hash_map 為:

  • 關聯的容器,為可變大小容器,支援項目值以關聯的索引鍵值為基礎、有效率的擷取。

  • 可逆轉的,因為它提供雙向的迭代器以存取其項目。

  • 已經過雜湊處理,因為其項目會依據套用至該項目索引鍵值之雜湊函式的值,分組到不同值區。

  • 唯一,因為它的每個項目都必須具有唯一索引鍵。

  • 一個成對關聯的容器,因為其項目資料值和其索引鍵值是不同的。

  • 類別範本,因為它所提供的功能是泛型的,因此與專案或索引鍵所包含的特定數據類型無關。 用於項目或索引鍵的資料類型是在類別樣板中指定為參數 (和比較函式與配置器一起指定)。

透過排序進行雜湊的主要優點是效率更佳;成功的雜湊能執行插入、刪除,相較於和排序技術容器中項目數目對數值成比例的時間,它會以常數平均時間進行搜尋。 中的 hash_map專案值,但不能直接變更其相關聯的索引鍵值。 相反地,與舊項目相關聯的索引鍵值必須刪除,然後插入與新項目相關聯的新索引鍵值。

選擇容器類型時,通常應根據應用程式所需的搜尋和插入類型。 經過雜湊處理的相關聯容器,已針對查閱、插入及移除作業進行過最佳化。 搭配設計良好的雜湊函式使用時,明確支援這些作業的成員函式,效率相當良好,其會以平均而言為常數的時間執行作業,而與此容器中的項目數目無關。 設計良好的雜湊函式會產生雜湊值的均勻分佈,並盡可能減少衝突發生,當相異索引鍵值對應到相同的雜湊值時,就會發生所謂的衝突。 使用最糟的雜湊函式的最壞情況下,作業數目與序列中的項目數目成正比 (線性時間)。

hash_map當應用程式滿足將值與其索引鍵建立關聯的條件時,應該是所選擇的關聯容器。 這個類型結構的模型是已排序的唯一關鍵字清單,舉例而言,其中關聯的字串值可提供定義。 相反地,如果字組有一個以上的正確定義,讓索引鍵不是唯一的,則 hash_multimap 會是選擇的容器。 另一方面,如果只儲存字組清單,則 會 hash_set 是正確的容器。 如果允許多個字組出現,則 hash_multiset 會是適當的容器結構。

hash_map藉由呼叫 類別value_compare的預存哈希Traits物件來排序它所控制的順序。 呼叫成員函 key_comp式 可以存取此預存物件。 這類函式對象的行為必須與 類別 hash_compare<Key, less<Key>>的物件相同。 更明確地說,針對 Key 類型的所有 Key 值,Traits( Key ) 呼叫會產生 size_t 類型值的分佈。 如需詳細資訊,請參閱hash_compare

一般而言,元素只需要小於可比較才能建立這個順序:因此,只要有任兩個元素,就可以判斷它們相等(從意義上說兩者都小於另一個元素),或一個小於另一個元素。 這會導致非對等元件之間的排序。 一個技術提示,比較函式是在標準數學概念上產生嚴格弱式順序的二元述詞。 二元述詞 f(x y) 是有兩個引數物件 xy 以及傳回值 truefalse 的函式物件。 如果二元述詞不具彈性、反對稱和可轉移性,且等價是可轉移的,則對 hash_map 的排序是嚴格的弱式排序,其中當 f(x、 y) 和 f(y, x) 和 f(y, x) false都是時,兩個 對象xy和 定義為相等。 如果更強的索引鍵相等條件取代等價條件,順序會變成總計 (也就是所有項目彼此相關的排序),因此相符的索引鍵之間將難以辨別。

受控制序列中實際的項目順序取決於雜湊函式、排序函式以及儲存於此容器物件中雜湊資料表目前的大小。 您無法判斷哈希表的目前大小,因此您無法一般預測受控制序列中元素的順序。 插入項目不會使任何迭代器無效,移除項目則僅會使特別指向被移除項目的迭代器無效。

類別所提供的 hash_map 反覆運算器是雙向反覆運算器,但類別成員函 insert 式和 hash_map 具有作為範本參數的較弱輸入反覆運算器的版本,其功能需求比雙向反覆運算器類別所保證的功能需求要小得多。 不同的迭代器概念因其功能的修改而形成關聯的系列。 每個迭代器概念有自己的一組需求,因此使用它們的演算法必須將其假設限制為該迭代器類型的需求。 可假設輸入迭代器可能已取值來參考某個物件,而且可能會遞增為序列中的下一個迭代器。 這是一組最少的功能,但足以在類別成員函式的內容中有意義地談論一系列反覆運算器 [First, Last)

建構函式

建構函式 描述
hash_map 建構一個空的 hash_map,或是其他 hash_map 的全部或部分複本。

Typedefs

類型名稱 描述
allocator_type 類型,表示 allocator 物件的 hash_map 類別。
const_iterator 提供雙向迭代器的類型,這個迭代器可以讀取 const 中的 hash_map 項目。
const_pointer 類型,提供 consthash_map 項目之指標。
const_reference 類型,提供儲存在 const 中供讀取和執行 hash_map 作業之 const 項目的參考。
const_reverse_iterator 提供雙向迭代器的類型,這個迭代器可以讀取 const 中的任何 hash_map 項目。
difference_type 帶正負號的整數類型,可以用來表示範圍 (介於迭代器所指的項目) 中 hash_map 的項目數。
iterator 類型,其提供可讀取或修改 hash_map 中任何項目的雙向迭代器。
key_compare 類型,提供可以比較兩個排序鍵的函式物件,以判斷兩個項目在 hash_map 中的相對順序。
key_type 類型,描述構成 hash_map 每個項目的排序鍵物件。
mapped_type 類型,表示儲存在 hash_map 中的資料類型。
pointer 類型,其提供 hash_map 中項目的指標。
reference 類型,提供儲存在 hash_map 中之項目的參考。
reverse_iterator 類型,提供可以讀取或修改反轉 hash_map 中之項目的雙向迭代器。
size_type 不帶正負號的整數類型,可以表示 hash_map 中的項目數。
value_type 類型,提供可將兩個項目做為排序鍵進行比較之函式物件,以判斷項目在 hash_map 中的相對順序。

成員函式

成員函數 描述
at hash_map 尋找具有指定索引鍵值的項目。
begin 傳回迭代器,為 hash_map 中的第一個項目定址。
cbegin 傳回常數迭代器,為 hash_map 中的第一個項目定址。
cend 傳回常數迭代器,為 hash_map 中最後一個項目的下一個位置定址。
clear 清除 hash_map 的所有項目。
count 傳回 hash_map 中索引鍵符合參數指定之索引鍵的項目數目。
crbegin const傳回反覆運算器,尋址反轉 hash_map中的第一個專案。
crend const 回反覆運算器,尋址物件是反轉 hash_map中最後一個項目之後的位置。
emplace 將就地建構的項目插入 hash_map 中。
emplace_hint 將就地建構的項目 (含位置提示) 插入 hash_map 中。
empty 測試 hash_map 是否為空白。
end 傳回迭代器,為 hash_map 中最後一個項目的下一個位置定址。
equal_range 傳回一組迭代器,分別指向 hash_map 中索引鍵大於特定索引鍵的第一個項目,以及指向 hash_map 中索引鍵等於或大於該索引鍵的第一個項目。
erase 從指定位置移除在 hash_map 中的項目或某個範圍的項目。
find 傳回迭代器,為 hash_map 中索引鍵等於指定索引鍵項目位置定址。
get_allocator 傳回用來建構 allocatorhash_map 物件複本。
insert 將項目或項目範圍插入至 hash_map
key_comp 傳回迭代器,指向 hash_map 中索引鍵值等於或大於特定索引鍵值的第一個項目。
lower_bound 傳回迭代器,指向 hash_map 中索引鍵值等於或大於特定索引鍵值的第一個項目。
max_size 傳回 hash_map 的最大長度。
rbegin 傳回迭代器,為反轉 hash_map 中的第一個項目定址。
rend 傳回迭代器,為反轉 hash_map 中最後一個項目的下一個位置定址。
size 傳回 hash_map 中項目的數目。
swap 交換兩個 hash_map 的項目。
upper_bound 傳回迭代器,其會指向 hash_map 中索引鍵值大於特定索引鍵值的第一個項目。
value_comp 擷取 hash_map 中用於排序項目值之比較物件的複本。

操作員

運算子 描述
operator[] 將具有特定索引鍵值的項目插入 hash_map 中。
hash_map::operator= 用另一個 hash_map 的複本取代 hash_map 的項目。

需求

標頭: <hash_map>

命名空間stdext

hash_map::allocator_type

注意

這個 API 已過時。 替代方法是 unordered_map Class

一種類型,代表 hash_map 物件的配置器類別。

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

範例

如需使用 allocator_type的範例,請參閱 範例get_allocator

hash_map::at

注意

這個 API 已過時。 替代方法是 unordered_map Class

hash_map 尋找具有指定索引鍵值的項目。

Type& at(const Key& key);

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

參數

key
所要尋找之元素的索引鍵值。

傳回值

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

備註

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

範例

// hash_map_at.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;

   // Insert data values
   hm1.insert ( cInt2Int ( 1, 10 ) );
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The values of the mapped elements are:";
   for ( int i = 1 ; i <= hm1.size() ; i++ )
      cout << " " << hm1.at(i);
   cout << "." << endl;
}

hash_map::begin

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回迭代器,為 hash_map 中的第一個項目定址。

const_iterator begin() const;

iterator begin();

傳回值

雙向反覆運算器,尋址中第一個專案 hash_map ,或位置接替空 hash_map的 。

範例

// hash_map_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 0, 0 ) );
   hm1.insert ( Int_Pair ( 1, 1 ) );
   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.begin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;

   hm1_Iter = hm1.begin ( );
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.begin ( );
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.begin( );
   cout << "The first element of hm1 is now "
        << hm1_cIter -> first << "." << endl;
}
The first element of hm1 is 0.
The first element of hm1 is now 1.

hash_map::cbegin

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回常數迭代器,為 hash_map 中的第一個項目定址。

const_iterator cbegin() const;

傳回值

常數雙向反覆運算器,尋址物件是 中的第一 hash_map 個專案,或位置接替空 hash_map的 。

範例

// hash_map_cbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 4 ) );

   hm1_cIter = hm1.cbegin ( );
   cout << "The first element of hm1 is "
        << hm1_cIter -> first << "." << endl;
   }
The first element of hm1 is 2.

hash_map::cend

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回常數迭代器,為 hash_map 中最後一個項目的下一個位置定址。

const_iterator cend() const;

傳回值

常數雙向反覆運算器,尋址對像是 中最後一個專案 hash_map後置的位置。 如果 hash_map 是空的,則 hash_map::cend == hash_map::begin

備註

cend 是用來測試迭代器是否已到達其 hash_map 的結尾。

cend 傳回的值不應該取值。

範例

// hash_map_cend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.cend( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;
   }
The value of last element of hm1 is 30.

hash_map::clear

注意

這個 API 已過時。 替代方法是 unordered_map Class

清除 hash_map 的所有項目。

void clear();

備註

範例

下列範例示範如何使用 hash_map::clear 成員函式。

// hash_map_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    hm1.insert(Int_Pair(2, 4));

    i = hm1.size();
    cout << "The size of the hash_map is initially "
         << i << "." << endl;

    hm1.clear();
    i = hm1.size();
    cout << "The size of the hash_map after clearing is "
         << i << "." << endl;
}
The size of the hash_map is initially 2.
The size of the hash_map after clearing is 0.

hash_map::const_iterator

注意

這個 API 已過時。 替代方法是 unordered_map Class

提供雙向迭代器的類型,這個迭代器可以讀取 const 中的 hash_map 項目。

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

備註

類型 const_iterator 無法用來修改專案的值。

const_iteratorhash_map定義的 ,指向 屬於的物件value_type,其pair< const Key, Type >第一個成員是 元素的索引鍵,而其第二個成員是 元素所持有的對應日期。

若要取值const_iteratorcIter指向 中的hash_map專案,請使用 -> 運算元。

若要存取項目的索引鍵值,請使用 cIter->first(*cIter).first相當於的 。 若要存取項目的對應日期值,請使用 cIter->second(*cIter).second相當於的 。

範例

如需使用 const_iterator的範例,請參閱 範例begin

hash_map::const_pointer

注意

這個 API 已過時。 替代方法是 unordered_map Class

類型,提供 consthash_map 項目之指標。

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;

備註

類型 const_pointer 無法用來修改專案的值。

在大部分情況下, iterator 應該使用 來存取 物件中的 hash_map 專案。

hash_map::const_reference

注意

這個 API 已過時。 替代方法是 unordered_map Class

類型,提供儲存在 const 中供讀取和執行 hash_map 作業之 const 項目的參考。

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;

備註

範例

// hash_map_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error because the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of the first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of the first element in the hash_map is "
        << Ref2 << "." << endl;
}
The key of the first element in the hash_map is 1.
The data value of the first element in the hash_map is 10.

hash_map::const_reverse_iterator

注意

這個 API 已過時。 替代方法是 unordered_map Class

提供雙向迭代器的類型,這個迭代器可以讀取 const 中的任何 hash_map 項目。

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse)iterator const_reverse_iterator;

備註

const_reverse_iterator 別無法修改專案的值,並用來反向逐一查看 hash_map

const_reverse_iteratorhash_map定義的 ,指向 屬於的物件value_type,其pair< const Key, Type >第一個成員是 元素的索引鍵,而其第二個成員是 元素所持有的對應日期。

若要取值const_reverse_iteratorcrIter指向 中的hash_map專案,請使用 -> 運算元。

若要存取項目的索引鍵值,請使用 crIter->first(*crIter).first相當於的 。 若要存取項目的對應日期值,請使用 crIter->second(*crIter).first相當於的 。

範例

如需如何宣告和使用 的const_reverse_iterator範例rend,請參閱範例。

hash_map::count

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回 hash_map 中索引鍵符合參數指定之索引鍵的項目數目。

size_type count(const Key& key) const;

參數

key
要從 hash_map比對之專案的索引鍵值。

傳回值

如果 hash_map 包含排序索引鍵符合參數索引鍵的專案,則為 1;如果 hash_map 不包含具有相符索引鍵的專案,則為 0。

備註

成員函式會傳回範圍中的項目 x 數目

lower_bound(key), upper_bound(key)

在的案例 hash_map中為 0 或 1,這是唯一的關聯容器。

範例

下列範例示範如何使用 hash_map::count 成員函式。

// hash_map_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair (1, 1));
    hm1.insert(Int_Pair (2, 1));
    hm1.insert(Int_Pair (1, 4));
    hm1.insert(Int_Pair (2, 1));

    // Keys must be unique in hash_map, so duplicates are ignored
    i = hm1.count(1);
    cout << "The number of elements in hm1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hm1.count(2);
    cout << "The number of elements in hm1 with a sort key of 2 is: "
         << i << "." << endl;

    i = hm1.count(3);
    cout << "The number of elements in hm1 with a sort key of 3 is: "
         << i << "." << endl;
}
The number of elements in hm1 with a sort key of 1 is: 1.
The number of elements in hm1 with a sort key of 2 is: 1.
The number of elements in hm1 with a sort key of 3 is: 0.

hash_map::crbegin

注意

這個 API 已過時。 替代方法是 unordered_map Class

const傳回反覆運算器,尋址反轉 hash_map中的第一個專案。

const_reverse_iterator crbegin() const;

傳回值

const反向雙向反覆運算器,尋址反hash_map轉中的第一個專案,或尋址未反hash_map轉 中的最後一個專案。

備註

crbegin與 反轉hash_map搭配使用,就像 搭配 使用一hash_mapbegin

使用 的 crbegin傳回值, hash_map 就無法修改 物件。

crbegin 可用來向後逐一查看 hash_map

範例

// hash_map_crbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}
The first element of the reversed hash_map hm1 is 3.

hash_map::crend

注意

這個 API 已過時。 替代方法是 unordered_map Class

const 回反覆運算器,尋址物件是反轉 hash_map中最後一個項目之後的位置。

const_reverse_iterator crend() const;

傳回值

const反向雙向反覆運算器,尋址對像是反轉中最後一個項目之後的位置(在未反hash_maphash_map的第一個元素之前的位置)。

備註

crend與 反轉hash_map搭配使用,就像 搭配 使用一hash_maphash_map::end

使用 的 crend傳回值, hash_map 就無法修改 物件。

crend 可以用來測試反轉迭代器是否已到達其 hash_map 的結尾。

crend 傳回的值不應該取值。

範例

// hash_map_crend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_crIter = hm1.crend( );
   hm1_crIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_crIter -> first << "." << endl;
}
The last element of the reversed hash_map hm1 is 3.

hash_map::difference_type

注意

這個 API 已過時。 替代方法是 unordered_map Class

帶正負號的整數類型,可以用來表示範圍 (介於迭代器所指的項目) 中 hash_map 的項目數。

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::difference_type difference_type;

範例

// hash_map_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 3, 20 ) );

   // The following won't insert, because map keys are unique
   hm1.insert ( Int_Pair ( 2, 30 ) );

   hash_map <int, int>::iterator hm1_Iter, hm1_bIter, hm1_eIter;
   hm1_bIter = hm1.begin( );
   hm1_eIter = hm1.end( );

   // Count the number of elements in a hash_map
   hash_map <int, int>::difference_type  df_count = 0;
   hm1_Iter = hm1.begin( );
   while ( hm1_Iter != hm1_eIter)
   {
      df_count++;
      hm1_Iter++;
   }

   cout << "The number of elements in the hash_map hm1 is: "
        << df_count << "." << endl;

   cout  << "The keys of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
         hm1_Iter++)
      cout << " " << hm1_Iter-> second;
   cout << "." << endl;
}
The number of elements in the hash_map hm1 is: 3.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 20.

hash_map::emplace

注意

這個 API 已過時。 替代方法是 unordered_map Class

將就地建構的項目插入 hash_map 中。

template <class ValTy>
pair <iterator, bool>
emplace(
    ValTy&& val);

參數

val
用來移動建構要插入的專案 hash_map 的值,除非 hash_map 已經包含該元素(或更一般說是索引鍵相等排序的專案)。

傳回值

成員 emplace 函式會傳回一對 bool ,其元件會在進行插入時傳回 true ,如果 false hash_map 已經包含索引鍵具有對等值的專案,且其 iterator 元件會傳回插入新元素的位址或元素所在的位置。

若要存取此成員函式所傳回之配對 priterator 元件,請使用 pr.first,若要取其值,請使用 *(pr.first)。 若要存取此成員函式所傳回之配對 prbool 元件,請使用 pr.second,若要取其值,請使用 *(pr.second)

備註

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

範例

// hash_map_emplace.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(move(is1));
    cout << "After the emplace insertion, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}
After the emplace insertion, hm1 contains:
1 => a

hash_map::emplace_hint

注意

這個 API 已過時。 替代方法是 unordered_map Class

將就地建構的項目 (含位置提示) 插入 hash_map 中。

template <class ValTy>
iterator emplace_hint(
    const_iterator _Where,
    ValTy&& val);

參數

val
用來移動建構要插入的專案 hash_map 的值,除非 hash_map 已經包含該元素(或更一般說是索引鍵相等排序的專案)。

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

傳回值

成員 hash_multimap::emplace 函式會傳回反覆運算器,指向新專案插入 至 hash_map的位置,或是具有對等順序的現有專案所在的位置。

備註

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

如果插入點緊接在 _Where 之後,便可以分攤的常數時間 (而不是對數時間) 進行插入。

範例

// hash_map_emplace_hint.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(hm1.begin(), move(is1));
    cout << "After the emplace, hm1 contains:" << endl
      << " " << hm1.begin()->first
      << " => " << hm1.begin()->second
      << endl;
}
After the emplace insertion, hm1 contains:
1 => a

hash_map::empty

注意

這個 API 已過時。 替代方法是 unordered_map Class

測試 hash_map 是否為空白。

bool empty() const;

傳回值

true 如果 是空的 hash_map ,則為 , false 如果 為空,則 hash_map 為 。

備註

範例

// hash_map_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2;

   typedef pair <int, int> Int_Pair;
   hm1.insert ( Int_Pair ( 1, 1 ) );

   if ( hm1.empty( ) )
      cout << "The hash_map hm1 is empty." << endl;
   else
      cout << "The hash_map hm1 is not empty." << endl;

   if ( hm2.empty( ) )
      cout << "The hash_map hm2 is empty." << endl;
   else
      cout << "The hash_map hm2 is not empty." << endl;
}
The hash_map hm1 is not empty.
The hash_map hm2 is empty.

hash_map::end

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回迭代器,為 hash_map 中最後一個項目的下一個位置定址。

const_iterator end() const;

iterator end();

傳回值

雙向反覆運算器,尋址對像是 中最後一個專案 hash_map後置的位置。 如果 hash_map 是空的,則 hash_map::end == hash_map::begin

備註

end 是用來測試迭代器是否已到達其 hash_map 的結尾。

end 傳回的值不應該取值。

範例

// hash_map_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: const_iterator hm1_cIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is "
        << hm1_cIter -> second << "." << endl;

   hm1_Iter = hm1.end( );
   hm1_Iter--;
   hm1.erase ( hm1_Iter );

   // The following 2 lines would err because the iterator is const
   // hm1_cIter = hm1.end ( );
   // hm1_cIter--;
   // hm1.erase ( hm1_cIter );

   hm1_cIter = hm1.end( );
   hm1_cIter--;
   cout << "The value of last element of hm1 is now "
        << hm1_cIter -> second << "." << endl;
}
The value of last element of hm1 is 30.
The value of last element of hm1 is now 20.

hash_map::equal_range

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回成對的迭代器,分別指向 hash_map 中索引鍵大於特定索引鍵的第一個項目,以及指向 hash_map 中索引鍵等於或大於該索引鍵的第一個項目。

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

參數

key
要與所搜尋專案排序索引鍵比較的 hash_map 自變數索引鍵值。

傳回值

一對反覆運算器,讓第一個是 lower_bound 索引鍵的 ,而第二個則是 upper_bound 索引鍵的 。

若要存取成員函式所傳回之配對 pr 的第一個反覆運算器,請使用 pr.first 和 來取值下限反覆運算器,請使用 *(pr.first)。 若要存取成員函式所傳回之配對 pr 的第二個反覆運算器,請使用 pr.second 和 來取值上限反覆運算器,請使用 *(pr.second)

備註

範例

// hash_map_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_map <int, int> IntMap;
   IntMap hm1;
   hash_map <int, int> :: const_iterator hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

   cout << "The lower bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with "
        << "a key of 2 in the hash_map hm1 is: "
        << p1.second -> second << "." << endl;

   // Compare the upper_bound called directly
   hm1_RcIter = hm1.upper_bound( 2 );

   cout << "A direct call of upper_bound( 2 ) gives "
        << hm1_RcIter -> second << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 2 )." << endl;

   p2 = hm1.equal_range( 4 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hm1.end( ) ) && ( p2.second == hm1.end( ) ) )
      cout << "The hash_map hm1 doesn't have an element "
             << "with a key less than 40." << endl;
   else
      cout << "The element of hash_map hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}
The lower bound of the element with a key of 2 in the hash_map hm1 is: 20.
The upper bound of the element with a key of 2 in the hash_map hm1 is: 30.
A direct call of upper_bound( 2 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 2 ).
The hash_map hm1 doesn't have an element with a key less than 40.

hash_map::erase

注意

這個 API 已過時。 替代方法是 unordered_map Class

從指定的位置移除 hash_map 中的項目或項目範圍,或移除符合指定之索引鍵的項目。

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

參數

_Where
要從 hash_map中移除之專案的位置。

first
hash_map移除的第一個專案位置。

last
位置剛好超過從 hash_map移除的最後一個專案。

key
要從 hash_map中移除之專案的索引鍵值。

傳回值

前兩個成員函式的雙向反覆運算器,指定任何移除之元素以外的第一個元素,或如果不存在這類專案,則為 結尾的 hash_map 指標。

針對第三個成員函式,傳回已從 hash_map中移除的項目數目。

備註

成員函式永遠不會擲回例外狀況。

範例

下列範例示範如何使用 hash_map::erase 成員函式。

// hash_map_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2, hm3;
    hash_map<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_map<int, int>::size_type n;
    typedef pair<int, int> Int_Pair;

    for (i = 1; i < 5; i++)
    {
        hm1.insert(Int_Pair (i, i));
        hm2.insert(Int_Pair (i, i*i));
        hm3.insert(Int_Pair (i, i-1));
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hm1.begin();
    hm1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_map hm1 is:";
    for (pIter = hm1.begin(); pIter != hm1.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hm2.begin();
    Iter2 = --hm2.end();
    hm2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_map hm2 is:";
    for (pIter = hm2.begin(); pIter != hm2.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hm3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hm3.begin();
    hm3.erase(Iter1);

    cout << "After another element with a key equal to that"
         << endl;
    cout  << "of the 2nd element is deleted, "
          << "the hash_map hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}
After the 2nd element is deleted, the hash_map hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_map hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_map hm3 is: 0 2 3.
The number of elements removed from hm3 is: 1.
After another element with a key equal to that
of the 2nd element is deleted, the hash_map hm3 is: 0 3.

hash_map::find

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回迭代器,為 hash_map 中索引鍵等於指定索引鍵項目位置定址。

iterator find(const Key& key);

const_iterator find(const Key& key) const;

參數

key
要與所搜尋專案排序索引鍵相符的 hash_map 索引鍵值。

傳回值

反覆運算器,尋址具有指定索引鍵的專案位置,或找不到索引鍵相符專案時,中最後一 hash_map 個專案的位置。

備註

find 會傳回反覆運算器,其排序索引鍵相當於二元述詞下自變數索引鍵的專案 hash_map ,該述詞會根據小於比較性關聯引發排序。

如果 的傳回值 find 指派給 const_iteratorhash_map 則無法修改 物件。 如果 的 find 傳回值指派給 iteratorhash_map 則可以修改 物件

範例

// hash_map_find.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.find( 2 );
   cout << "The element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1.find( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1.find( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}
The element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

hash_map::get_allocator

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回用來建構 hash_map的配置器對象的複本。

Allocator get_allocator() const;

傳回值

所使用的 hash_map配置器。

備註

類別的配置 hash_map 器會指定類別管理記憶體的方式。 C++ 標準程式庫容器類別隨附的預設配置器,足以滿足大多數程式設計需求。 撰寫和使用您自己的配置器類別是進階 C++ 主題。

範例

// hash_map_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int>::allocator_type hm1_Alloc;
   hash_map <int, int>::allocator_type hm2_Alloc;
   hash_map <int, double>::allocator_type hm3_Alloc;
   hash_map <int, int>::allocator_type hm4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   hash_map <int, int> hm1;
   hash_map <int, int> hm2;
   hash_map <int, double> hm3;

   hm1_Alloc = hm1.get_allocator( );
   hm2_Alloc = hm2.get_allocator( );
   hm3_Alloc = hm3.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm2.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hm3.max_size( ) <<  "." << endl;

   // The following line creates a hash_map hm4
   // with the allocator of hash_map hm1.
   hash_map <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( hm1_Alloc == hm4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_map::hash_map

注意

這個 API 已過時。 替代方法是 unordered_map Class

hash_map建構空的 ,或是其他hash_map部分 之所有或部分的複本。

hash_map();

explicit hash_map(
    const Traits& Comp);

hash_map(
    const Traits& Comp,
    const Allocator& Al);

hash_map(
    const hash_map& Right);

hash_map(
    hash_map&& Right);

hash_map(
    initializer_list<Type> IList);hash_map(initializer_list<Type> IList,
    const key_compare& Comp);

hash_map(
    initializer_list<Type> IList,
    const key_compare& Comp,
    const allocator_type& Al);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
hash_map(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al

參數

Al
要用於此 hash_map 物件的儲存體配置器類別,預設為 Allocator

Comp
const Traits 類型的比較函式,用來排序 中的 hash_map專案,其預設為 hash_compare

Right
hash_map建構的對應為複本的 。

First
要複製的元素範圍中第一個元素的位置。

Last
超出要複製之元素範圍的第一個元素的位置。

IList
initializer_list

備註

所有建構函式都會儲存一種配置器物件類型,可管理的 hash_map 記憶體記憶體記憶體記憶體,稍後可呼叫 get_allocator傳回 。 在類別宣告以及用來取代替代配置器的前置處理巨集中,經常會省略 allocator 參數。

所有建構函式都會初始化其 hash_map

所有建構函式都會儲存型 Traits 別的函式物件,用來在 的 hash_map 索引鍵之間建立順序,稍後可藉由呼叫 key_comp傳回。

前三個建構函式會指定空的初始 hash_map,此外,第二個建構函式會指定要用於建立元素順序的比較函式類型,Comp而第三個建構函式會明確指定要使用的配置器類型 (Al)。 關鍵字 explicit 會隱藏某些類型的自動類型轉換。

第四個建構函式會指定的hash_mapRight複本。

接下來的三個建構函式會在指定 類別Traits和設定器的比較函式類型時,複製 具有遞增明確性的 範圍。[First, Last) hash_map

最後建構函式會hash_mapRight移動 。

hash_map::insert

注意

這個 API 已過時。 替代方法是 unordered_map Class

將項目或項目範圍插入至 hash_map

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

iterator insert(
    const_iterator _Where,
    const value_type& val);

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

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

template <class ValTy>
iterator insert(
    const_iterator _Where,
    ValTy&& val);

參數

val
要插入 至 hash_map 的專案值,除非 hash_map 已經包含該元素(或更普遍的是索引鍵相等排序的專案)。

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

first
要從 hash_map 複製之第一個元素的位置。

last
緊接在要從 hash_map 複製之最後一個元素後面的位置。

傳回值

第一個 insert 成員函式會傳回一對 bool ,其元件會在進行插入時傳回 true ,如果 false hash_map 已經包含索引鍵具有對等值的專案,而反覆運算器元件會傳回插入新元素的位址,或元素所在的位置。

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

第二 insert 個成員函式提示版本會傳回反覆運算器,指向插入 hash_map新專案的位置。

最後兩 insert 個成員函式的行為與前兩個函式相同,不同之處在於它們會移動建構插入的值。

備註

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

針對插入的提示版本,如果插入點緊接在 _Where 之後,便可以分攤的常數時間 (而不是對數時間) 進行插入。

第三個成員函式會將專案值序列插入對應至 hash_map 指定集合範圍內 *[First, Last)* 反覆運算器所尋址的每個元素。

範例

// hash_map_insert.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int>::iterator hm1_pIter, hm2_pIter;

    hash_map<int, int> hm1, hm2;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 10));
    hm1.insert(Int_Pair(2, 20));
    hm1.insert(Int_Pair(3, 30));
    hm1.insert(Int_Pair(4, 40));

    cout << "The original elements (Key => Value) of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << " " << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    pair< hash_map<int,int>::iterator, bool > pr;
    pr = hm1.insert(Int_Pair(1, 10));

    if (pr.second == true)
    {
        cout << "The element 10 was inserted in hm1 successfully."
            << endl;
    }
    else
    {
        cout << "The element 10 already exists in hm1\n"
            << "with a key value of "
            << "((pr.first) -> first) = " << (pr.first)->first
            << "." << endl;
    }

    // The hint version of insert
    hm1.insert(--hm1.end(), Int_Pair(5, 50));

    cout << "After the insertions, the elements of hm1 are:";
    for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
        cout << endl << hm1_pIter -> first << " => "
             << hm1_pIter->second;
    cout << endl;

    hm2.insert(Int_Pair(10, 100));

    // The templatized version inserting a range
    hm2.insert( ++hm1.begin(), --hm1.end() );

    cout << "After the insertions, the elements of hm2 are:";
    for (hm2_pIter = hm2.begin(); hm2_pIter != hm2.end(); hm2_pIter++)
        cout << endl << hm2_pIter -> first << " => "
             << hm2_pIter->second;
    cout << endl;

    // The templatized versions move constructing elements
    hash_map<int, string> hm3, hm4;
    pair<int, string> is1(1, "a"), is2(2, "b");

    hm3.insert(move(is1));
    cout << "After the move insertion, hm3 contains:" << endl
      << hm3.begin()->first
      << " => " << hm3.begin()->second
      << endl;

    hm4.insert(hm4.begin(), move(is2));
    cout << "After the move insertion, hm4 contains:" << endl
      << hm4.begin()->first
      << " => " << hm4.begin()->second
      << endl;
}
The original elements (Key => Value) of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
The element 10 already exists in hm1
with a key value of ((pr.first) -> first) = 1.
After the insertions, the elements of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
5 => 50
After the insertions, the elements of hm2 are:
2 => 20
10 => 100
3 => 30
4 => 40
After the move insertion, hm3 contains:
1 => a
After the move insertion, hm4 contains:
2 => b

hash_map::iterator

注意

這個 API 已過時。 替代方法是 unordered_map Class

類型,其提供可讀取或修改 hash_map 中任何項目的雙向迭代器。

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

備註

iteratorhash_map定義的 ,指向 屬於的物件value_type,其pair<const Key, Type>第一個成員是 元素的索引鍵,而其第二個成員是 元素所持有的對應日期。

若要取值指向 multimap 中元素的 Iter 反覆運算器,請使用 -> 運算符。

若要存取項目的索引鍵值,請使用 Iter->first(*Iter).first相當於的 。 若要存取項目的對應日期值,請使用 Iter->second(*Iter).second相當於的 。

iterator 別可用來修改專案的值。

範例

begin如需如何宣告和使用 的iterator範例,請參閱 範例。

hash_map::key_comp

注意

這個 API 已過時。 替代方法是 unordered_map Class

擷取 hash_map 中用來排序索引鍵的比較物件之複本。

key_compare key_comp() const;

傳回值

傳回 用來排序其專案的函式物件 hash_map

備註

預存物件會定義成員函式

bool operator( const Key& left, const Key&right );

如果 left 前面與不等於right排序順序,則會傳true回 。

範例

// hash_map_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >::key_compare
      kc1 = hm1.key_comp( ) ;

   // Operator stored in kc1 tests order & returns bool value
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true,"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false"
           << "\n where kc1 is the function object of hm1"
           << " of type key_compare." << endl;
   }

   hash_map <int, int, hash_compare<int, greater<int> > > hm2;
   hash_map <int, int, hash_compare<int, greater<int> > >
      ::key_compare kc2 = hm2.key_comp( );

   // Operator stored in kc2 tests order & returns bool value
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,"
           << "\n where kc2 is the function object of hm2"
           << " of type key_compare." << endl;
   }
}

hash_map::key_compare

注意

這個 API 已過時。 替代方法是 unordered_map Class

一種提供函式物件的類型,該函式物件可比較兩個排序鍵來判斷對應中兩個元素的相對順序。

typedef Traits key_compare;

備註

key_compare 與樣板參數 Traits 同義。

如需詳細資訊 Traitshash_map 請參閱類別 主題。

範例

key_comp如需如何宣告和使用 key_compare的範例,請參閱 範例。

hash_map::key_type

注意

這個 API 已過時。 替代方法是 unordered_map Class

類型,描述構成 hash_map 每個項目的排序鍵物件。

typedef Key key_type;

備註

key_type 與樣板參數 Key 同義。

如需 的詳細資訊Key,請參閱類別主題的hash_map一節。

範例

value_type如需如何宣告和使用 key_type的範例,請參閱 範例。

hash_map::lower_bound

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回迭代器,指向 hash_map 中索引鍵值等於或大於特定索引鍵值的第一個項目。

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

參數

key
要與所搜尋專案排序索引鍵比較的 hash_map 自變數索引鍵值。

傳回值

iteratorconst_iterator ,尋址物件為索引鍵等於或大於自變數索引鍵之 中hash_map專案的位置,如果找不到索引鍵相符專案,則尋址中最後hash_map一個項目之後的位置。

如果 的傳回值 lower_bound 指派給 const_iteratorhash_map 則無法修改 物件。 如果 的傳回值 lower_bound 指派給 iteratorhash_map 則可以修改 物件。

備註

範例

// hash_map_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.lower_bound( 2 );
   cout << "The first element of hash_map hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end( ) is returned
   hm1_RcIter = hm1. lower_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // An element at a specific location in the hash_map can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.end( );
   hm1_AcIter--;
   hm1_RcIter = hm1. lower_bound ( hm1_AcIter -> first );
   cout << "The element of hm1 with a key matching "
        << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;
}
The first element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.

hash_map::mapped_type

注意

這個 API 已過時。 替代方法是 unordered_map Class

類型,表示儲存在 hash_map 中的資料類型。

typedef Type mapped_type;

備註

類型 mapped_type 與範本參數 Type 同義。

如需詳細資訊 Typehash_map 請參閱類別 主題。

範例

value_type如需如何宣告和使用 key_type的範例,請參閱 範例。

hash_map::max_size

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回 hash_map 的最大長度。

size_type max_size() const;

傳回值

的最大可能長度 hash_map

備註

範例

// hash_map_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: size_type i;

   i = hm1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_map is " << i << "."
        << endl << "(Magnitude is machine specific.)";
}

hash_map::operator[]

注意

這個 API 已過時。 替代方法是 unordered_map Class

將具有特定索引鍵值的項目插入 hash_map 中。

Type& operator[](const Key& key);

Type& operator[](Key&& key);

參數

key
所要插入之元素的索引鍵值。

傳回值

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

備註

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

operator[] 可用來將元素插入到 hash_map m,方法是使用

m[ key] = DataValue;

其中 DataValue 是索引鍵值為 key 之元素的 mapped_type 值。

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

範例

// hash_map_op_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: iterator pIter;

   // Insert a data value of 10 with a key of 1
   // into a hash_map using the operator[] member function
   hm1[ 1 ] = 10;

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( hash_map <int, int> :: value_type ( 2, 20 ) );
   hm1.insert ( cInt2Int ( 3, 30 ) );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // If the key already exists, operator[]
   // changes the value of the datum in the element
   hm1[ 2 ] = 40;

   // operator[] will also insert the value of the data
   // type's default constructor if the value is unspecified
   hm1[5];

   cout  << "The keys of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are now:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;

   // operator[] will also insert by moving a key
   hash_map <string, int> hm2;
   string str("a");
   hm2[move(str)] = 1;
   cout << "The moved key is " << hm2.begin()->first
      << ", with value " << hm2.begin()->second << endl;
}

hash_map::operator=

注意

這個 API 已過時。 替代方法是 unordered_map Class

用另一個 hash_map 的複本取代 hash_map 的項目。

hash_map& operator=(const hash_map& right);

hash_map& operator=(hash_map&& right);

參數

right
right複製到的hash_map類別

備註

清除 hash_map 中的任何現有項目之後,operator= 會將 right 的內容複製或移到 hash_map 中。

範例

// hash_map_operator_as.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map<int, int> v1, v2, v3;
   hash_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;
}

hash_map::pointer

注意

這個 API 已過時。 替代方法是 unordered_map Class

類型,其提供 hash_map 中項目的指標。

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::pointer pointer;

備註

pointer 別可用來修改專案的值。

在大部分情況下, iterator 應該使用 來存取 物件中的 hash_map 專案。

hash_map::rbegin

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回迭代器,為反轉 hash_map 中的第一個項目定址。

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

傳回值

反向雙向反覆運算器,尋址反 hash_map 轉中的第一個專案,或尋址未反 hash_map轉 中的最後一個專案。

備註

rbegin與 反轉hash_map搭配使用,就像 搭配 使用一hash_mapbegin

如果 的傳回值 rbegin 指派給 const_reverse_iterator,則 hash_map 無法修改 物件。 如果 的 rbegin 傳回值指派給 reverse_iteratorhash_map 則可以修改 物件。

rbegin 可用來向後逐一查看 hash_map

範例

// hash_map_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rbegin( );
   cout << "The first element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( ); hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = hm1.rbegin( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}
The first element of the reversed hash_map hm1 is 3.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the first element in the reversed hash_map is 2.

hash_map::reference

注意

這個 API 已過時。 替代方法是 unordered_map Class

類型,提供儲存在 hash_map 中之項目的參考。

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;

備註

範例

// hash_map_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );

   // Declare and initialize a const_reference &Ref1
   // to the key of the first element
   const int &Ref1 = ( hm1.begin( ) -> first );

   // The following line would cause an error as the
   // non-const_reference cannot be used to access the key
   // int &Ref1 = ( hm1.begin( ) -> first );

   cout << "The key of first element in the hash_map is "
        << Ref1 << "." << endl;

   // Declare and initialize a reference &Ref2
   // to the data value of the first element
   int &Ref2 = ( hm1.begin( ) -> second );

   cout << "The data value of first element in the hash_map is "
        << Ref2 << "." << endl;

   // The non-const_reference can be used to modify the
   // data value of the first element
   Ref2 = Ref2 + 5;
   cout << "The modified data value of first element is "
        << Ref2 << "." << endl;
}
The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The modified data value of first element is 15.

hash_map::rend

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回迭代器,為反轉 hash_map 中最後一個項目的下一個位置定址。

const_reverse_iterator rend() const;

reverse_iterator rend();

傳回值

反向雙向反覆運算器,尋址對像是反轉中最後一個項目之後的位置(在未反hash_maphash_map的第一個元素之前的位置)。

備註

rend與 反轉hash_map搭配使用,就像 搭配 使用一hash_mapend

如果 的傳回值 rend 指派給 const_reverse_iterator,則 hash_map 無法修改 物件。 如果 的 rend 傳回值指派給 reverse_iteratorhash_map 則可以修改 物件。

rend 可以用來測試反轉迭代器是否已到達其 hash_map 的結尾。

rend 傳回的值不應該取值。

範例

// hash_map_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;

   hash_map <int, int> :: iterator hm1_Iter;
   hash_map <int, int> :: reverse_iterator hm1_rIter;
   hash_map <int, int> :: const_reverse_iterator hm1_crIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "The last element of the reversed hash_map hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_map in a forward order
   cout << "The hash_map is: ";
   for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( );
   hm1_Iter++)
      cout << hm1_Iter -> first << " ";
      cout << "." << endl;

   // rbegin can be used to start an iteration
   // through a hash_map in a reverse order
   cout << "The reversed hash_map is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( );
      hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_map element can be erased by dereferencing to its key
   hm1_rIter = --hm1.rend( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rend( );
   hm1_rIter--;
   cout << "After the erasure, the last element "
        << "in the reversed hash_map is "
        << hm1_rIter -> first << "." << endl;
}
The last element of the reversed hash_map hm1 is 1.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the last element in the reversed hash_map is 2.

hash_map::reverse_iterator

注意

這個 API 已過時。 替代方法是 unordered_map Class

類型,提供可以讀取或修改反轉 hash_map 中之項目的雙向迭代器。

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

備註

reverse_iterator 別無法修改專案的值,並用來反向逐一查看 hash_map

reverse_iteratorhash_map定義的 ,指向屬於value_type對象的專案,其類型為 pair<const Key, Type>,其第一個成員是元素的索引鍵,而其第二個成員是元素所持有的對應日期。

若要取值reverse_iteratorrIter指向 中的hash_map專案,請使用 -> 運算元。

若要存取項目的索引鍵值,請使用 rIter->first(*rIter).first相當於的 。 若要存取項目的對應日期值,請使用 rIter->second(*rIter).first相當於的 。

範例

rbegin如需如何宣告和使用 reverse_iterator的範例,請參閱 範例。

hash_map::size

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回 hash_map 中項目的數目。

size_type size() const;

傳回值

的目前長度 hash_map

備註

範例

下列範例示範如何使用 hash_map::size 成員函式。

// hash_map_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_map<int, int> hm1, hm2;
    hash_map<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    i = hm1.size();
    cout << "The hash_map length is " << i << "." << endl;

    hm1.insert(Int_Pair(2, 4));
    i = hm1.size();
    cout << "The hash_map length is now " << i << "." << endl;
}
The hash_map length is 1.
The hash_map length is now 2.

hash_map::size_type

注意

這個 API 已過時。 替代方法是 unordered_map Class

不帶正負號的整數類型,可以表示 hash_map 中的項目數。

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;

備註

範例

size如需如何宣告和使用範例,請參閱範例size_type

hash_map::swap

注意

這個 API 已過時。 替代方法是 unordered_map Class

交換兩個 hash_map 的項目。

void swap(hash_map& right);

參數

right
提供要與目標 hash_map交換之元素的自變數hash_map

備註

成員函式不會使任何參考、指標或反覆運算器失效,這些反覆運算器會指定正在交換其專案之兩 hash_map個 中的元素。

範例

// hash_map_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1, hm2, hm3;
   hash_map <int, int>::iterator hm1_Iter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );
   hm2.insert ( Int_Pair ( 10, 100 ) );
   hm2.insert ( Int_Pair ( 20, 200 ) );
   hm3.insert ( Int_Pair ( 30, 300 ) );

   cout << "The original hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;

   // This is the member function version of swap
   // hm2 is said to be the argument hash_map;
   // hm1 is said to be the target hash_map
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hm1, hm3 );

   cout << "After swapping with hm3, hash_map hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}
The original hash_map hm1 is: 10 20 30.
After swapping with hm2, hash_map hm1 is: 100 200.
After swapping with hm3, hash_map hm1 is: 300.

hash_map::upper_bound

注意

這個 API 已過時。 替代方法是 unordered_map Class

將反覆運算器傳回至 中具有大於指定索引鍵之值之 中的 hash_map 第一個專案。

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

參數

key
要與所搜尋專案排序索引鍵值比較的 hash_map 自變數索引鍵值。

傳回值

iteratorconst_iterator ,其尋址物件為索引鍵大於自變數索引鍵之 中hash_map專案的位置,如果找不到索引鍵相符專案,則尋址中最後一hash_map個項目之後的位置。

如果傳回值指派給 const_iteratorhash_map 則無法修改 物件。 如果傳回值指派給 iteratorhash_map 則可以修改 物件。

備註

範例

// hash_map_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_map <int, int> hm1;
   hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
   typedef pair <int, int> Int_Pair;

   hm1.insert ( Int_Pair ( 1, 10 ) );
   hm1.insert ( Int_Pair ( 2, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_map hm1 with a key "
        << "greater than 2 is: "
        << hm1_RcIter -> second << "." << endl;

   // If no match is found for the key, end is returned
   hm1_RcIter = hm1. upper_bound ( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_map hm1 doesn't have an element "
           << "with a key greater than 4." << endl;
   else
      cout << "The element of hash_map hm1 with a key > 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_map can be found
   // using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.begin( );
   hm1_RcIter = hm1. upper_bound ( hm1_AcIter -> first );
   cout << "The 1st element of hm1 with a key greater than that\n"
        << "of the initial element of hm1 is: "
        << hm1_RcIter -> second << "." << endl;
}
The first element of hash_map hm1 with a key greater than 2 is: 30.
The hash_map hm1 doesn't have an element with a key greater than 4.
The 1st element of hm1 with a key greater than that
of the initial element of hm1 is: 20.

hash_map::value_comp

注意

這個 API 已過時。 替代方法是 unordered_map Class

傳回函式對象,這個物件會比較元素的索引鍵值,以判斷 中的 hash_map 項目順序。

value_compare value_comp() const;

傳回值

傳回 用來排序其項目的比較函式物件 hash_map

備註

針對 ,如果兩個hash_map元素 (, ) 和 (k2d2) 是類型的物件,d1其中 k1k2 e2 是其類型的key_typevalue_type索引鍵,d1而且d2是其型mapped_type別的數據,則 m.value_comp()(e1, e2) 相當於 。m.key_comp()(k1, k2)k1e1 m 預存物件會定義成員函式

bool operator(value_type& left, value_type& right);

如果索引鍵值left在 之前,且不等於排序順序中的 索引鍵值right,則會傳回 true

範例

// hash_map_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_map <int, int, hash_compare<int, less<int> > > hm1;
   hash_map <int, int, hash_compare<int, less<int> > >
   ::value_compare vc1 = hm1.value_comp( );
   pair< hash_map<int,int>::iterator, bool > pr1, pr2;

   pr1= hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );
   pr2= hm1.insert ( hash_map <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *pr1.first, *pr2.first ) == true )
   {
      cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
           << endl;
   }
   else
   {
      cout << "The element ( 1,10 ) does not precede the element ( 2,5 )."
           << endl;
   }

   if( vc1 ( *pr2.first, *pr1.first ) == true )
   {
      cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
           << endl;
   }
   else
   {
      cout << "The element ( 2,5 ) does not precede the element ( 1,10 )."
           << endl;
   }
}

hash_map::value_type

注意

這個 API 已過時。 替代方法是 unordered_map Class

型別,表示儲存在 中的 hash_map物件型別。

typedef pair<const Key, Type> value_type;

備註

value_type 宣告為 pair<const key_type, mapped_type> 且不是 pair<key_type, mapped_type> ,因為關聯容器的索引鍵可能無法使用非常數反覆運算器或參考來變更。

範例

// hash_map_value_type.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef pair <const int, int> cInt2Int;
   hash_map <int, int> hm1;
   hash_map <int, int> :: key_type key1;
   hash_map <int, int> :: mapped_type mapped1;
   hash_map <int, int> :: value_type value1;
   hash_map <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );

   // Compare other ways to insert objects into a hash_map
   hm1.insert ( cInt2Int ( 2, 20 ) );
   hm1[ 3 ] = 30;

   // Initializing key1 and mapped1
   key1 = ( hm1.begin( ) -> first );
   mapped1 = ( hm1.begin( ) -> second );

   cout << "The key of first element in the hash_map is "
        << key1 << "." << endl;

   cout << "The data value of first element in the hash_map is "
        << mapped1 << "." << endl;

   // The following line would cause an error because
   // the value_type is not assignable
   // value1 = cInt2Int ( 4, 40 );

   cout  << "The keys of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> first;
   cout << "." << endl;

   cout  << "The values of the mapped elements are:";
   for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
      cout << " " << pIter -> second;
   cout << "." << endl;
}
The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.

另請參閱

C++ 標準程式庫中的執行緒安全
C++ 標準程式庫參考