哈希表

公司提供了一套接口供客戶開發應用。這套接口的框架是用IPCRPC實現，嚴格意義上說這是僞IPCRPC,由於不涉及機器之間的通訊，只是不一樣進程間的通訊。

提供給客戶的接口裏面，其實只是經過socket發送信息到一個相似daemon的進程，具體的操做都是在deamon進程中，處理完後將結果返回給應用進程。mdnsResponder也是採用這樣的思路。

在接口裏面，將接口的函數名字和參數打包發給daemon進程，在daemon進程將一些相同名字的函數註冊到一個哈希表中，當收到應用進程發來的函數名字後，直接查找哈希表，調用相應的函數。

基於上面這種想法，實現一個哈希表，以函數名爲key,以函數做爲value.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct _HashNode{
　　char *key;
　　void *value;
　　struct _HashNode *prev;
　　struct _HashNode *next;
}HashNode;
typedef struct _HashList{
　　HashNode *pListHead;//鏈表頭
　　int elemNum;//鏈表中元素個數
}HashList;
typedef struct _HashTable{
　　HashList *pTable;
　　unsigned long tableSize;
}HashTable;//哈希表的每一項都是一個雙鏈表
HashTable gHashTable;
typedef int (*Handle)();

void hash_init(HashTable *hashTable, unsigned long tableSize)
{
　　hashTable->pTable = (HashList *)malloc(tableSize * sizeof(HashList));
　　memset(hashTable->pTable, 0, tableSize * sizeof(HashList));
　　hashTable->tableSize = tableSize;
}
unsigned long hash_func(const char *key, unsigned long tableSize)
{
　　char *tmp = NULL;
　　unsigned long hashCode = 0;
　　for (tmp = key; *tmp != '\0'; tmp++)
　　{
　　　　hashCode = hashCode * 31 + *tmp;
　　}
　　hashCode = hashCode & (tableSize - 1);
　　return hashCode;
}

void hash_add(HashTable *hashTable, const char *key, void *value)
{
　　unsigned long hashCode = hash_func(key, hashTable->tableSize);
　　HashNode *pNode = (HashNode *)malloc(sizeof(HashNode));
　　pNode->key = key;
　　pNode->value = value;
　　pNode->prev = pNode->next = NULL;
　　if (hashTable->pTable[hashCode].pListHead == NULL)
　　{
　　　　hashTable->pTable[hashCode].pListHead = pNode;
　　}
　　else
　　{
　　　　pNode->next = hashTable->pTable[hashCode].pListHead;
　　　　hashTable->pTable[hashCode].pListHead->prev = pNode;
　　　　hashTable->pTable[hashCode].pListHead = pNode;
　　}
　　hashTable->pTable[hashCode].elemNum++;
}

int hash_get(HashTable *hashTable, const char *key, void **value)
{
　　unsigned long hashCode = hash_func(key, hashTable->tableSize);
　　if (hashTable->pTable[hashCode].pListHead == NULL)
　　{
　　　　printf("key:%s NOT found\n", key);
　　　　return 0;
　　}
　　else
　　{
　　　　HashNode *tmp = NULL;
　　　　for (tmp = hashTable->pTable[hashCode].pListHead; tmp; tmp = tmp->next)
　　　　{
　　　　　　if(!strncmp(tmp->key, key, strlen(key)))
　　　　　　{
　　　　　　　　if (value)
　　　　　　　　{
　　　　　　　　　　*value = tmp->value;
　　　　　　　　}
　　　　　　　　return 1;
　　　　　　}
　　　　}
　　}
　　printf("1key:%s NOT found\n", key);
　　return 0;
}

int handle_fellow_open()
{
　　printf("fellow open!\n");
}
　　int handle_fellow_close()
{
　　printf("fellow close!\n");
}
int handle_fellow_play()
{
　　printf("fellow play!\n");
}
void reg_handle_func(HashTable *hashTable, const char *key, Handle handle)
{
　　printf("reg %s, 0x%x\n", key, (int)handle);
　　if (hash_get(hashTable, key, NULL))
　　{
　　　　printf("already exist\n");
　　　　return;
　　}
　　hash_add(hashTable, key, handle);

}
#define REG_HANDLE(name) \
do{reg_handle_func(&gHashTable, #name, handle_##name);}while(0)

void init_handle()
{
　　REG_HANDLE(fellow_open);
　　REG_HANDLE(fellow_close);
　　REG_HANDLE(fellow_play);
}

void main(void)
{
　　hash_init(&gHashTable, 1024);
　　init_handle();
　　Handle handle;
　　hash_get(&gHashTable, "fellow_play", (void **)&handle);
　　handle();
　　reg_handle_func(&gHashTable, "fellow_open", handle_fellow_open);
　　hash_get(&gHashTable, "fellow_close", (void **)&handle);
　　handle();

}

運行結果以下：