簡単な実装のハッシュマップの一種

// テンプレート<クラスT>
 // 利用ID来索引到对应的对象
構造体HashNode {
     int型のID。
    無効 * OBJ。
    構造体LIST_HEAD list_item。
} 

構造体LIST_HEAD { 
    LIST_HEAD * PREV。
    LIST_HEAD * 次の; 
} 
の#define LIST_HEAD_INIT（名）{＆（名）、＆（名）}
 の#define INIT_LIST_HEAD（PTR）を実行{（PTR） - >次=（PTR）。（PTR） - > PREV =（PTR）。}（0）、一方
 の#defineためlist_for_each（POS、ヘッド）（POS =（ヘッド） - >次に、POS =（ヘッド）; POS = POS->次！）
 の#define用list_for_each_safe（POS、N、頭部）（POS =（ヘッド） - >次に、N = POS->次に、POS =（ヘッド）; POS = N、N = POS->次！）
 静的インラインボイド list_add（構造体 LIST_HEAD * P、
                               構造体 LIST_HEAD * PREV、
                               構造体 LIST_HEAD * 次）
{ 
    次 - > PREV = P。
    P - =>次の次。
    P - > PREV = 前; 
    PREV - >次= P; 
} 
静的インラインボイド list_add_in（構造体 LIST_HEADの* pを、構造体 LIST_HEAD * ヘッド）
{ 
    list_add（P、頭、頭 - > 次）; 
} 
静的インラインボイド list_add_tail（構造体 LIST_HEADの* pを、構造体 LIST_HEAD * ヘッド）
{ 
    list_add（P、ヘッド - > PREV、ヘッド）
} 
静的インラインボイド（__list_del 構造体 LIST_HEAD * PREV、構造体 LIST_HEAD * 次）
{ 
    次 - > PREV = PREV。
    PREV - =>次の次。
} 
静的インラインボイド list_del（構造体 LIST_HEAD * エントリ）
{ 
    __list_del（エントリ - > PREV、エントリー・> 次）; 
    エントリ - >次= 0 ; 
    エントリ - > PREV = 0 ; 
} 


#ifndefのoffsetofは
#ifの __GNUC__> = 4 の#define offsetofは（タイプ、メンバー）（タイプ、メンバー）__builtin_offsetof;のprintf（ "これはGCC> 4 \ nが"）。
#else の#define（タイプ、メンバー）（unsigned long型）offsetofは（＆（（タイプ*）0） - >メンバー）;のprintf（ "これはGCC <4 \であるN"）。
#endifの#endifのに#define LIST_ENTRY（PTR、タイプ、メンバー）（（型部材）-offsetof（タイプ*）（（CHAR *）（PTR）））







クラスCHashMap {
 プライベート：
     構造体 HashNode * hash_table。
    int型のhash_table_size。

公共：
    CHashMap（）; 
    〜CHashMap（）;
    int型 CreateMap（int型map_size）。
    int型 AddMapObj（int型の ID、無効 * OBJ）。
    INT DelMapObj（int型のID）;
    無効 * GetMapObj（int型のID）;
    int型ClearMap（）;    
} 

CHashMap（）{ 
    hash_table =  NULL;
    hash_table_size = 0 ; 
}
〜CHashMap（）{
     場合（hash_table）{ 
        ClearMap（）。
    } 
    hash_table_size = 0 。
} 
INT CreateMap（INT map_size）{
     試みる{ 
        hash_table = 新しいHashNode [map_size]。
    } キャッチ（＆bad_alloc）{
         リターン - 1 。
    } 
    // 对每个ハッシュ桶的头节点进行初始化
    ため（int型 I = 0 ; iがmap_sizeを<; I ++）{
        hash_table [I] .ID OBJ。 = 0 。
        hash_table [I] .OBJ = NULL; 
        INIT_LIST_HEAD（ ＆hash_table [I] .list_item）。
    } 
    hash_table_size = map_size。
    リターン 0 ; 
} 

INT AddMapObj（INT ID、ボイド * OBJ）{
     int型 bucket_id =識別％のhash_table_size。
    HashNode * TEMP = 新しい 構造体HashNode（）; 
    TEMP - > ID = ID。
    TEMP - > OBJ = 
    list_add_tail（＆temp-> list_item、＆hash_table [bucket_id] .list_item）。
    リターン 0 ; 
} 
INT DelMapObj（INT ID）
{ 
    int型 bucket_id =識別％のhash_table_size。
    構造体 LIST_HEAD * TEMP1。
    構造体 LIST_HEAD * TEMP2。
    構造体 LIST_HEAD *ヘッド=＆.list_item [bucket_id] hash_table。
    構造体 HashNode * ノード。
    
    list_for_each_safe（TEMP1、TEMP2、ヘッド）
    { 
        ノード = LIST_ENTRY（TEMP1、構造体HashNode、list_item）。
        もし（ノード- > ID == ID）
        { 
            list_del（TEMP1）。
            削除したノードを、
            リターン 0 ; 
        } 
    } 
    リターン - 1 。
    
} 
ボイド * GetMapObj（int型のID）{
     int型 bucket_id =識別％のhash_table_size。
    構造体 LIST_HEAD *ヘッド=＆.list_item [bucket_id] hash_table。
    構造体 LIST_HEAD * TEMP。
    構造体 HashNode * ノード。
    list_for_each（TEMP、ヘッド）
    { 
        ノード = LIST_ENTRY（TEMP、構造体HashNode、list_item）;
        もし（ノード- > ID == ID）{
             戻りノード- > OBJ。
        } 
    } 
    戻りNULL。
} 
INT ClearMap（）
{ 
    構造体 LIST_HEAD * _head。
    構造体 LIST_HEAD * _tmp1。
    構造体 LIST_HEAD * _tmp2。
    構造体のObjectMap *   項目。

    以下のために（int型 i = 0 ; iはhash_table_size <; iは++ ）
    { 
        _head =＆hash_table [I] .list_item。    // ヘッド节点并没有存储数据、不需要析构
        list_for_each_safe（_tmp1、_tmp2、_head）
        { 
            アイテム = LIST_ENTRY（_tmp1、構造体のObjectMap、list_item）。
            list_del（_tmp1）。
            削除した項目を、
        } 
    } 

    削除[] hash_tableします。
    hash_table = NULL; 
    hash_table_size = 0 ; 

    リターン 0 ; 
}

テンプレート<型名ノードタイプ>
 構造体HashListNode 
{ 
    OBJノードタイプ。
    構造体LIST_HEAD list_item。
}。
テンプレート <型名ノードタイプ、型名形質>
 INT IDX =形質:: GetNodeID（OBJ）％のhash_table_size。

簡単な実装のハッシュマップの一種

おすすめ