hash_map::hash_map

[!メモ]

この API は、互換性のために残されています。代わりに unordered_map クラスです。

空か、他の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
);
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
   );
hash_map(
   hash_map&& _Right
);

パラメーター

パラメーター	説明
_Al	Allocatorに既定では、このhash_mapのオブジェクトに使用するストレージのアロケーター クラス。
_Comp	hash_compareに既定でhash_mapの要素を並べ替えに使用される型 [const][Traits] の比較関数。
_Right	構築されたマップがコピーであることですhash_map。
_First	コピーする要素範囲内の先頭の要素の位置。
_Last	コピーする要素範囲を超える最初の要素の位置。

解説

すべてのコンストラクターはhash_mapのメモリの記憶域を管理する get_allocatorを呼び出して後で、アロケーター オブジェクトの種類を格納します。アロケーターのパラメーターは、代替アロケーターを置き換えるために使用されるクラスの宣言とプリプロセッサ マクロに切り捨てられます。

すべてのコンストラクターは、のhash_mapを初期化します。

すべてのコンストラクターはhash_mapのキーの間の順序を確立するために使用される key_compを呼び出して後で、型 [Traits] 関数オブジェクトを格納します。

また、を明示的に使用されるアロケーターの型 (_Al) を指定する最初の3のコンストラクターは、空の初期hash_mapを指定し、2番目の要素と番目の順序の確立に使用する比較関数 (_Comp) の型を指定します。キーワード explicit は、特定の種類の自動型変換を抑制します。

4つ目のコンストラクターは、hash_map _Rightのコピーを指定します。

次の3種類のコンストラクターは、アロケーター クラス [Traits] との比較関数の型の指定を大きくするexplicitnessのhash_mapの範囲[_First、_Last) をコピーします。

最後のコンストラクターはhash_map _Rightを実行します。

使用例

// hash_map_hash_map.cpp
// compile with: /EHsc
#include <ostream>
#include <hash_map>
#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;

typedef char * MyStr;

struct MyInt
{
    int i;
    friend ostream& operator<<(ostream& ii, MyInt& jj);
    MyInt(int j = 0) {
        i = j;
    }
};

struct greater_str
{
    bool operator()(const MyStr & x, const MyStr & y) const {
        if (strcmp(x, y) < 0)
            return true;

        return false;
    }
};


struct less_str {
    bool operator()(const MyStr & x, const MyStr & y) const
    {
        if (strcmp(x, y) > 0)
            return true;

        return false;
    }
};

ostream& operator<<(ostream& o, MyInt& j) {
    o << j.i;
    return o;
}

int main()
{
    using namespace stdext;
    typedef pair <MyStr, MyInt> Int_Pair;
    hash_map<MyStr, MyInt>::iterator hm1_Iter, hm3_Iter, hm4_Iter, hm5_Iter, hm6_Iter, hm7_iter;
    hash_map<MyStr, MyInt, hash_compare<MyStr, greater_str> >::iterator hm2_Iter;

    // Create an empty hash_map hm0 of key type integer
    hash_map<MyStr, MyInt> hm0;

    // Create an empty hash_map hm1 with the key comparison
    // function of less than, then insert 4 elements
    hash_map<MyStr, MyInt, hash_compare<MyStr, less_str> > hm1;

    hm1.insert(Int_Pair("one",  0));
    hm1.insert(Int_Pair("two", 10));
    hm1.insert(Int_Pair("three", 20));
    hm1.insert(Int_Pair("four", 30));
    hm1.insert(Int_Pair("five", 40));

    // Create an empty hash_map hm2 with the key comparison
    // function of geater than, then insert 2 elements
    hash_map<MyStr, MyInt, hash_compare<MyStr, greater_str> > hm2;
    hm2.insert(Int_Pair("one", 10));
    hm2.insert(Int_Pair("two", 20));

    // Create a hash_map hm3 with the
    // allocator of hash_map hm1
    hash_map<MyStr, MyInt>::allocator_type hm1_Alloc;
    hm1_Alloc = hm1.get_allocator();
    hash_map<MyStr, MyInt, hash_compare<MyStr, less_str> > hm3(hash_compare<MyStr, less_str > (), hm1_Alloc);
    hm3.insert(Int_Pair("three", 30));

    // Create a copy, hash_map hm4, of hash_map hm1
    hash_map<MyStr, MyInt, hash_compare<MyStr, less_str> > hm4(hm1);

    // Create a hash_map hm5 by copying the range hm1[_First, _Last)
    hash_map<MyStr, MyInt>::const_iterator hm1_bcIter, hm1_ecIter;
    hm1_bcIter = hm1.begin();
    hm1_ecIter = hm1.begin();
    hm1_ecIter++;
    hm1_ecIter++;
    hash_map<MyStr, MyInt> hm5(hm1_bcIter, hm1_ecIter);

    // Create a hash_map hm6 by copying the range hm4[_First, _Last)
    // and with the allocator of hash_map hm2
    hash_map<MyStr, MyInt>::allocator_type hm2_Alloc;
    hm2_Alloc = hm2.get_allocator();
    hash_map<MyStr, MyInt, hash_compare<MyStr, less_str> > hm6(hm4.begin(), ++hm4.begin(), hash_compare<MyStr, less_str > (), hm2_Alloc);

    cout << "hm1 =";
    for (hm1_Iter = hm1.begin(); hm1_Iter != hm1.end(); hm1_Iter++)
        cout << " " << hm1_Iter -> second;
    cout << endl;

    cout << "hm2 =";
    for (hm2_Iter = hm2.begin(); hm2_Iter != hm2.end(); hm2_Iter++)
        cout << " " << hm2_Iter -> second;
    cout << endl;

    cout << "hm3 =";
    for (hm3_Iter = hm3.begin(); hm3_Iter != hm3.end(); hm3_Iter++)
        cout << " " << hm3_Iter -> second;
    cout << endl;

    cout << "hm4 =";
    for (hm4_Iter = hm4.begin(); hm4_Iter != hm4.end(); hm4_Iter++)
        cout << " " << hm4_Iter -> second;
    cout << endl;

    cout << "hm5 =";
    for (hm5_Iter = hm5.begin(); hm5_Iter != hm5.end(); hm5_Iter++)
        cout << " " << hm5_Iter -> second;
    cout << endl;

    cout << "hm6 =";
    for (hm6_Iter = hm6.begin(); hm6_Iter != hm6.end(); hm6_Iter++)
        cout << " " << hm6_Iter -> second;
    cout << endl;

    // Create a copy, hash_map hm7, of hash_map hm1 by moving
    hash_map<MyStr, MyInt, hash_compare<MyStr, less_str> >
        hm7(move(hm1));
    cout << "hm7 =";
    for (hm7_Iter = hm7.begin(); hm7_Iter != hm7.end(); hm7_Iter++)
        cout << " " << hm7_Iter -> second;
    cout << endl;
}

出力例

hm1 = 20 0 30 40 10
hm2 = 10 20
hm3 = 30
hm4 = 20 0 30 40 10
hm5 = 0 20
hm6 = 20
hm7 = 20 0 30 40 10

必要条件

ヘッダー: <hash_map>

名前空間: のstdext

参照

関連項目

hash_map Class

標準テンプレート ライブラリ