通过对《Redis设计与实现》一书的学习，我打算动手自己实现一份“Redis源代码”作为自己的学习记录。
对Redis感兴趣的同学可以查看我的另一篇文章 造个轮子 | 自己动手写一个Redis。
本章介绍的是Redis源代码中的字典及其内部哈希表的实现。
字典dict的实现
dict的API
（1）创建一个新的字典
dict dictCreate(dictType type,int hashSize);
（2）根据key寻找其在hashTable中对应的结点
dictEntry lookup(dict d,void *key);
（3）将给定的键值对添加到字典里面
（如果键已经存在于字典，那么用新值取代原有的值）
bool dictInsert(dict d, void key, void *val);
（4）返回给定的键的值
void dictFetchValue(dict d, void *key);
（5）从字典中删除给定键所对应的键值对
void dictDelete(dict d, void key);
（6）释放给定字典，以及字典中包含的所有键值对
void dictRelease(dict *d);
头文件
#ifndef __DICT_H
#define __DICT_H
//哈希表的结点使用dictEntry结构来表示
//每个dictEntry结构都保存着一个key-value
typedef struct dictEntry{
//键
void *key;
//值
void *value;
//指向下个哈希表结点，形成链表——避免键冲突
struct dictEntry *next;
}dictEntry;
//保存一组用于操作特定类型键值对的函数
typedef struct dictType {
//计算哈希值的函数
unsigned int (*hashFunction)(void *key,int size);
//复制键的函数
void *(*keyDup)(void *key);
//复制值的函数
void *(*valDup)(void *obj);
//对比键的函数
int (*keyCompare)(void *key1, void *key2);
//销毁键的函数
void (*keyDestructor)(void *key);
//销毁值的函数
void (*valDestructor)(void *obj);
} dictType;
//哈希表
typedef struct dictht {
//哈希表数组
dictEntry **table;
//哈希表大小
int size;
//该哈希表已有结点的数量
int used;
} dictht;
//字典
//其实字典就是对普通的哈希表再做一层封装
//增加了一些属性
typedef struct dict {
//类型特定函数
dictType *type;
//哈希表
dictht *ht;
} dict;
//创建一个新的字典
//需要传入哈希表的大小
dict *dictCreate(dictType *type,int hashSize);
//根据key寻找其在hashTable中对应的结点
dictEntry* lookup(dict *d,void *key);
//将给定的键值对添加到字典里面
//将给定的键值对添加到字典里面，如果键已经存在于字典，
//那么用新值取代原有的值
bool dictInsert(dict *d, void *key, void *val);
//返回给定的键的值
void *dictFetchValue(dict *d, void *key);
//从字典中删除给定键所对应的键值对
void dictDelete(dict *d, void *key);
//释放给定字典，以及字典中包含的所有键值对
void dictRelease(dict *d);
#endifdict API的实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "dict.h"
//哈希表的大小
#define HASHSIZE 10
//定义对哈希表进行相关操作的函数集
//计算哈希值的函数
unsigned int myHashFunction(void *key,int size){
char* charkey=(char*)key;
unsigned int hash=0;
for(;*charkey;++charkey){
hash=hash*33+*charkey;
}
return hash%size;
}
//复制键的函数
void *myKeyDup(void *key){
return key;
}
//复制值的函数
void *myValDup(void *obj){
return obj;
}
//对比键的函数
int myKeyCompare(void *key1, void *key2){
char*charkey1=(char*)key1;
char*charkey2=(char*)key2;
return strcmp(charkey1,charkey2);
}
//销毁键的函数
void myKeyDestructor(void *key){
//free(key);
}
//销毁值的函数
void myValDestructor(void *obj){
//free(obj);
}
//创建一个新的字典
dict *dictCreate(dictType *type,int hashSize){
dict* d=(dict*)malloc(sizeof(dict));
//对hashTable进行相关操作的特定函数集
if(type==NULL){
printf("PIG Redis WARNING : Type is NULL.\n");
}
d->type=type;
//哈希表初始化
d->ht=(dictht*)malloc(sizeof(dictht));
d->ht->size=hashSize;
d->ht->used=0;
d->ht->table=(dictEntry**)malloc(sizeof(dictEntry*)*hashSize);
//全部结点都设为NULL
for(int i=0;i<hashSize;i++){
d->ht->table[i]=NULL;
}
return d;
}
//根据key寻找其在hashTable中对应的结点
dictEntry* lookup(dict *d,void *key){
dictEntry* node;
//该key在hashTable中对应的下标
unsigned int index;
index=d->type->hashFunction(key,d->ht->size);
for(node=d->ht->table[index];node;node=node->next){
if(!(d->type->keyCompare(key,node->key))){
return node;
}
}
return NULL;
}
//将给定的键值对添加到字典里面
bool dictInsert(dict *d, void *key, void *val){
unsigned int index;
dictEntry* node;
if(!(node=lookup(d,key))){
index=d->type->hashFunction(key,d->ht->size);
node=(dictEntry*)malloc(sizeof(dictEntry));
if(!node)return false;
node->key=d->type->keyDup(key);
node->next=d->ht->table[index];
d->ht->table[index]=node;
}
//若存在,直接修改其对应的value值
node->value=d->type->valDup(val);
return true;
}
//返回给定的键的值
void *dictFetchValue(dict *d, void *key){
unsigned int index;
dictEntry* node;
//找不到这个结点
if(!(node=lookup(d,key))){
return NULL;
}
return node->value;
}
//从字典中删除给定键所对应的键值对
void dictDelete(dict *d, void *key){
dictEntry* node;
dictEntry* temp;
//该key在hashTable中对应的下标
unsigned int index;
index=d->type->hashFunction(key,d->ht->size);
node=d->ht->table[index];
//key相同
if(!(d->type->keyCompare(key,node->key))){
d->ht->table[index]=node->next;
d->type->keyDestructor(node->key);
d->type->valDestructor(node->value);
free(node);
return;
}
temp=node;
node=node->next;
while(node){
if(!(d->type->keyCompare(key,node->key))){
temp->next=node->next;
d->type->keyDestructor(node->key);
d->type->valDestructor(node->value);
free(node);
return;
}
temp=node;
node=node->next;
}
return;
}
//释放给定字典，以及字典中包含的所有键值对
void dictRelease(dict *d){
dictEntry* node;
dictEntry* temp;
for(int i=0;i<d->ht->size;i++){
node=d->ht->table[i];
//printf("%d\n",i);
while(node){
char* t=(char*)node->value;
//printf("%s\n",t);
temp=node;
node=node->next;
d->type->keyDestructor(temp->key);
d->type->valDestructor(temp->value);
free(temp);
}
}
free(d->ht);
free(d->type);
free(d);
}
/*int main(){
dictType*type=(dictType*)malloc(sizeof(dictType));
type->hashFunction=myHashFunction;
type->keyDup=myKeyDup;
type->valDup=myValDup;
type->keyCompare=myKeyCompare;
type->keyDestructor=myKeyDestructor;
type->valDestructor=myValDestructor;
dict* d=dictCreate(type,HASHSIZE);
char*key1="sss";
char*value1="111";
bool result=dictInsert(d,key1,value1);
if(result){
printf("insert1 success\n");
}else{
printf("insert1 fail\n");
}
char*key2="3sd";
char*value2="ddd";
result=dictInsert(d,key2,value2);
if(result){
printf("insert2 success\n");
}else{
printf("insert2 fail\n");
}
char*key3="ddds";
char*value3="1ss";
result=dictInsert(d,key3,value3);
if(result){
printf("insert3 success\n");
}else{
printf("insert3 fail\n");
}
char *value4=(char*)dictFetchValue(d,key3);
printf("---%s\n",value4);
dictDelete(d,key3);
value4=(char*)dictFetchValue(d,key3);
printf("---%s\n",value4);
dictRelease(d);
system("pause");
return 0;
}*/