沉淀之log4c的hash

    上回书说到，log4c的list模块，咱们书接上回，说一说他的hash模块，仍然用以模块代码进行注释的形式进行。
头文件如下：
hash.h：
  1. /* $Id: hash.h,v 1.4 2005/05/24 15:33:18 legoater Exp $
  2.  *
  3.  * Copyright 2001-2003, Meiosys (www.meiosys.com). All rights reserved.
  4.  * Author: Marc Vertes <mvertes@meiosys.com>
  5.  * See the COPYING file for the terms of usage and distribution.
  6.  */
  8. #ifndef __sd_hash_h
  9. #define __sd_hash_h
  11. /**
  12.  * @file hash.h
  13.  *
  14.  * @brief Generic hash table. It is implemented as an array of doubly-linked
  15.  * lists of iterators. The index within the array is computed by a efficient
  16.  * hash function.
  17.  */
  19. #include <stddef.h>
  20. #include <sd/defs.h>
  22. __SD_BEGIN_DECLS
  24. struct __sd_hash_ops {
  25.     unsigned int	(*hash)		(const void*);
  26.     int			(*compare)	(const void*, const void*);
  27.     void*		(*key_dup)	(const void*);
  28.     void		(*key_free)	(void*);
  29.     void*		(*data_dup)	(const void*);
  30.     void		(*data_free)	(void*);
  31. };
  32. /**
  33.  * 这个结构体保存hash表的操作信息
  34.  */
  35. typedef struct __sd_hash_ops sd_hash_ops_t;
  36. /**
  37.  * hash表的结构体类型
  38.  */
  39. typedef struct __sd_hash sd_hash_t;
  41. struct __sd_hash_iter {
  42.     void*			key;
  43.     void*			data;
  44.     struct __sd_hash*		hash;
  45.     unsigned int		__hkey;
  46.     struct __sd_hash_iter*	__next;
  47.     struct __sd_hash_iter*	__prev;
  48.     int				__foreach;
  49. };
  51. /**
  52.  * hash表元素的容器，用来存放用户数据
  53.  */
  54. typedef struct __sd_hash_iter sd_hash_iter_t;
  55. /**
  56.  * 遍历的回调函数类型
  57.  */
  58. typedef unsigned int (*sd_hash_func_t)(void* a_key, void* a_data,
  59. 				       void* a_userdata);
  60. /**
  61.  * 新建一个hash表，用户可以指定内存的分配方式以及key值计算和数据存储方式
  62.  * @param a_size 初始化数组的大小
  63.  * @param a_ops  hash操作函数，如果是NULL，默认字符串key值算法，另外没有为
  64.  * key值计算和用户数据存储方式
  65.  * @return hash表结构
  66.  */
  67. extern sd_hash_t* sd_hash_new(size_t a_size, const sd_hash_ops_t* a_ops);
  68. /**
  69.  * 销毁一个hash表
  70.  */
  71. extern void sd_hash_delete(sd_hash_t* a_this);
  72. /**
  73.  * 清空一个hash表
  74.  */
  75. extern void sd_hash_clear(sd_hash_t* a_this);
  76. /**
  77.  * 根据key值在hash表里查找元素容器
  78.  * @param a_key key值
  79.  * @return 指向找到的结构体地址或者NULL
  80.  */
  81. extern sd_hash_iter_t* sd_hash_lookup(sd_hash_t* a_this, const void* a_key);
  82. /**
  83.  * 根据key值在hash表里查找元素容器，如果不存在就新建一个。
  84.  * @param a_key 与待查找容器相关联的key值
  85.  * @return 返回查找到的容器或者NULL.
  86.  */
  87. extern sd_hash_iter_t* sd_hash_lookadd(sd_hash_t* a_this, const void* a_key);
  88. /**
  89.  * 通过给定的数据key值添加用户数据到hash表，如果已经存在那么就通过hash操作中的
  90.  * 释放接口进行释放之前的，并将当前数据插入
  91.  * @param a_key 容器的键值key值
  92.  * @param a_data 数据
  93.  * @return 返回指向数据容器的指针.
  94.  */
  95. extern sd_hash_iter_t* sd_hash_add(sd_hash_t* a_this, const void* a_key,
  96. 				 void* a_data);
  97. /**
  98.  * 从hash表中移除一个容器
  99.  * @param 容器的key值
  100.  */
  101. extern void sd_hash_del(sd_hash_t* a_this, const void* a_key);
  102. /**
  103.  * 调用回调函数a_fun遍历整个hash，直到该回调返回非0
  104.  * @param a_func 回调函数
  105.  * @param a_data 用户数据传如到a_func
  106.  */
  107. extern void sd_hash_foreach(sd_hash_t* a_this, sd_hash_func_t a_func,
  108. 			    void* a_data);
  109. /**
  110.  * 获得hash表中所有的容器个数
  111.  */
  112. extern unsigned int sd_hash_get_nelem(sd_hash_t* a_this);
  113. /**
  114.  * 获得hash表的大小
  115.  */
  116. extern unsigned int sd_hash_get_size(sd_hash_t* a_this);
  118. /**
  119.  * 获取hash表的第一个元素容器
  120.  */
  121. extern sd_hash_iter_t* sd_hash_begin(sd_hash_t* a_this);
  123. /**
  124.  * 获取hash表的最后一个元素容器
  125.  */
  126. extern sd_hash_iter_t* sd_hash_end(sd_hash_t* a_this);
  127. /**
  128.  * 获取当前容器的下一个容器
  129.  */
  130. extern sd_hash_iter_t* sd_hash_iter_next(sd_hash_iter_t* a_this);
  131. /**
  132.  * 获取当前容器的上一个容器
  133.  */
  134. extern sd_hash_iter_t* sd_hash_iter_prev(sd_hash_iter_t* a_this);
  135. /**
  136.  * 删除一个容器，根据容器地址
  137.  */
  138. extern void sd_hash_iter_del(sd_hash_iter_t* a_this);
  139. /**
  140.  * Hashes strings.计算key值
  141.  */
  142. extern unsigned int sd_hash_hash_string(const char* a_string);
  144. __SD_END_DECLS
  146. #endif
    头文件里面定义了hash操作的结构体，hash表元素容器的结构体，以及hash表的类型，其中hash表的类型是在hash.c中进行定义的，这样很好的屏蔽了hash结构。
    对于hash表的结构体定义如下：
  1. #define SD_HASH_FULLTAB	2	/* rehash when table gets this x full */
  2. #define SD_HASH_GROWTAB 4	/* grow table by this factor */
  3. #define SD_HASH_DEFAULT_SIZE 10 /* self explenatory */
  5. struct __sd_hash {
  6.     size_t			nelem;			//hash表中元素个数
  7.     size_t			size;			//hash大小
  8.     sd_hash_iter_t**		tab;	//元素容器的表
  9.     const sd_hash_ops_t*	ops;	//hash操作
  10. };
  12. #define hindex(h, n)	((h)%(n))	//计算hashkey

通过以上各个结构体的定义可以先给出整个hash表的总体结构，然后后续参考sd_hash_new进一步进行理解。

图一：hash结构图

具体代码以及分析如下：
sd_hash_new：
  1. /******************************************************************************/
  2. //创建一个hash表
  3. //a_size	hash表能够容纳元素的数量
  4. //a_ops		hash操作集合
  5. extern sd_hash_t* sd_hash_new(size_t a_size, const sd_hash_ops_t* a_ops)
  6. {
  7. 	//一个默认的hash操作集合、hash值计算，比较等
  8.     const static sd_hash_ops_t default_ops = {
  9. 	(void*) &sd_hash_hash_string,
  10. 	(void*) &strcmp,
  11. 	0, 0, 0, 0
  12.     };
  13.     //分配hash表和容器表内存并进行检查
  14.     sd_hash_t*		hash;
  15.     sd_hash_iter_t**	tab;
  16.     
  17.     if (a_size == 0) a_size = SD_HASH_DEFAULT_SIZE;
  18.     
  19.     hash	= sd_calloc(1, sizeof(*hash));
  20.     tab		= sd_calloc(a_size, sizeof(*tab));
  21.     
  22.     if (hash == 0 || tab == 0) {
  23. 	free(hash);
  24. 	free(tab);
  25. 	return 0;
  26.     }
  27.     //初始化元素个数，大小，容器表地址以及操作集合
  28.     hash->nelem	= 0;
  29.     hash->size	= a_size;
  30.     hash->tab	= tab;
  31.     hash->ops	= a_ops != 0 ? a_ops : &default_ops;
  32.     
  33.     return hash;
  34. }

sd_hash_delete：
  1. /******************************************************************************/
  2. //销毁一个hash表，先将hash表清空，然后将hash进行回收
  3. //a_this	待清空的hash表
  4. extern void sd_hash_delete(sd_hash_t* a_this)
  5. {
  6. 	//将hash表中的元素进行清空
  7.     sd_hash_clear(a_this);
  8. 	//释放hash的容器表和hash表
  9.     free(a_this->tab);
  10.     free(a_this);
  11. }

sd_hash_clear：
  1. /******************************************************************************/
  2. //清空一个hash表中的元素
  3. //a_this	待清空的hash表
  4. extern void sd_hash_clear(sd_hash_t* a_this)
  5. {
  6.     size_t		h;
  7.     sd_hash_iter_t*	p;
  8.     sd_hash_iter_t*	q;
  9.     
  10.     if (a_this == 0) return;
  11.     //遍历一个hash的所有容器指针的下挂的所有容器，进行释放
  12.     for (h = 0; h < a_this->size; h++) {
  13. 	for (p = a_this->tab[h]; p; p = q) {
  14. 	    q = p->__next;
  15. 	    if (a_this->ops->key_free) a_this->ops->key_free(p->key);
  16. 	    if (a_this->ops->data_free) a_this->ops->data_free(p->data);
  17. 	    free(p);
  18. 	}
  19. 	a_this->tab[h] = 0;
  20.     }
  21.     a_this->nelem = 0;
  22. }

sd_hash_lookup：
  1. /**
  2.  * 根据key值在hash表里查找元素容器
  3.  * @param a_key key值
  4.  * @return 		指向找到的结构体地址或者NULL
  5.  */
  6. extern sd_hash_iter_t* sd_hash_lookup(sd_hash_t* a_this, const void* a_key)
  7. {
  8.     int			h;
  9.     sd_hash_iter_t*	p;
  10.     //参数判断
  11.     if (a_this == 0 || a_key == 0) return 0;
  12.     //计算hash值
  13.     h = hindex(a_this->ops->hash(a_key), a_this->size);
  14. 	//遍历该hash值所对应的容器指针下挂的所有容器并进行比较验证
  15.     for (p = a_this->tab[h]; p != 0; p = p->__next)
  16. 	if (a_this->ops->compare(a_key, p->key) == 0) {
  17. 	    return p;
  18. 	}
  19.     
  20.     return 0;
  21. }

sd_hash_lookadd：
  1. /**
  2.  * 根据key值在hash表里查找元素容器，如果不存在就新建一个。
  3.  * @param a_key 与待查找容器相关联的key值
  4.  * @return 返回查找到的容器或者NULL.
  5.  */
  6. extern sd_hash_iter_t* sd_hash_lookadd(sd_hash_t* a_this, const void* a_key)
  7. {
  8.     int			h;
  9.     sd_hash_iter_t*	p;
  10.     
  11.     if (a_this == 0 || a_key == 0)			return 0;
  12. 	//先查找一遍，已经存在就进行返回，否则就分配空间然后进行初始化
  13.     if ((p = sd_hash_lookup(a_this, a_key)) != 0)	return p;
  14.     if ((p = sd_calloc(1, sizeof(*p))) == 0)		return 0;
  15.     //如果有复制数据功能那么就复制一份否则就用原始数据
  16.     if (a_this->ops->key_dup != 0)
  17. 	p->key = a_this->ops->key_dup(a_key);
  18.     else
  19. 	p->key = (void*) a_key;
  20.     //初始化容器一些参数
  21.     p->hash					= a_this;
  22.     p->__hkey					= a_this->ops->hash(a_key);
  23.     //如果超过当前hash最大容量那么就进行扩张
  24.     if (a_this->nelem > SD_HASH_FULLTAB * a_this->size) rehash(a_this);
  25.     
  26.     h						= hindex(p->__hkey,
  27. 							 a_this->size);
  28. 	//将当前容器挂到对应key值的容器指针下挂链表中。
  29.     p->__next					= a_this->tab[h];
  30.     a_this->tab[h]				= p;
  31.     if (p->__next != 0) p->__next->__prev	= p;
  32.     //计数
  33.     a_this->nelem++;
  34.     
  35.     return p;
  36. }

sd_hash_add：
  1. /**
  2.  * 通过给定的数据key值添加用户数据到hash表，如果已经存在那么就通过hash操作中的
  3.  * 释放接口进行释放之前的，并将当前数据插入
  4.  * @param a_key 容器的键值key值
  5.  * @param a_data 数据
  6.  * @return 返回指向数据容器的指针.
  7.  */
  8. extern sd_hash_iter_t* sd_hash_add(sd_hash_t* a_this, const void* a_key,
  9. 				   void* a_data)
  10. {
  11.     sd_hash_iter_t* p;
  12.     //调用lookadd进行插入
  13.     if ((p = sd_hash_lookadd(a_this, a_key)) == 0) return 0;
  14.     //如果这个值已经存在，那么就释放了然后重新进行赋值当前值
  15.     if (a_this->ops->data_free != 0) a_this->ops->data_free(p->data);
  16.     //判断释放需要进行备份并进行赋值
  17.     if (a_this->ops->data_dup != 0)
  18. 	p->data = a_this->ops->data_dup(a_data);
  19.     else
  20. 	p->data = a_data;
  21.     
  22.     return p;
  23. }

sd_hash_del：
  1. /**
  2.  * 从hash表中移除一个容器
  3.  * @param 容器的key值
  4.  */
  5. extern void sd_hash_del(sd_hash_t* a_this, const void* a_key)
  6. {
  7.     int			h;
  8.     sd_hash_iter_t*	p;
  9.     //定位容器的容器指针
  10.     h = hindex(a_this->ops->hash(a_key), a_this->size);
  11. 	//循环遍历容器指针下挂的链表找到待删除容器进行删除
  12.     for (p = a_this->tab[h]; p != 0; p = p->__next)
  13. 	if (a_this->ops->compare(a_key, p->key) == 0) break;
  14.     if (p == 0) return;
  15.     //进行删除
  16.     sd_hash_iter_del(p);
  17. }

sd_hash_foreach：
  1. /**
  2.  * 调用回调函数a_fun遍历整个hash，直到该回调返回非0
  3.  * @param a_func 回调函数
  4.  * @param a_data 用户数据传如到a_func
  5.  */
  6. extern void sd_hash_foreach(sd_hash_t* a_this, sd_hash_func_t a_func,
  7. 			    void* a_data)
  8. {
  9.     size_t			h, ret;
  10.     sd_hash_iter_t*	p;
  11.     sd_hash_iter_t*	q;
  12.     //参数验证
  13.     if (a_this == 0 || a_func == 0) return;
  14.     //定位容器指针，找到容器
  15.     for (h = 0; h < a_this->size; h++)
  16. 	for (p = a_this->tab[h]; p != 0; p = q) {
  17. 	    p->__foreach		= 1;
  18. 		//调用遍历回调函数进行操作
  19. 	    ret			= (*a_func)(p->key, p->data, a_data);
  20. 	    q			= p->__next;
  21. 	    //删除重复表项
  22. 	    if (p->__foreach == 0)
  23. 		sd_hash_iter_del(p);
  24. 	    else
  25. 		p->__foreach	= 0;
  26. 	    
  27. 	    if (ret != 0) return;
  28. 	}
  29. }

sd_hash_get_nelem：
  1. /**
  2.  * 获得hash表中所有的容器个数
  3.  */
  4. extern unsigned int sd_hash_get_nelem(sd_hash_t* a_this)
  5. {
  6.     if (a_this == 0) return 0;
  7.     return a_this->nelem;
  8. }

sd_hash_get_size：
  1. /**
  2.  * 获得hash表的大小
  3.  */
  4. extern unsigned int sd_hash_get_size(sd_hash_t* a_this)
  5. {
  6.     if (a_this == 0) return 0;
  7.     return a_this->size;
  8. }

sd_hash_begin：
  1. /**
  2.  * 获取hash表的第一个元素容器
  3.  */
  4. extern sd_hash_iter_t* sd_hash_begin(sd_hash_t* a_this)
  5. {
  6.     size_t h;
  7.     
  8.     if (a_this == 0) return 0;
  9.     for (h = 0; h < a_this->size; h++)
  10. 	if (a_this->tab[h])
  11. 	    return a_this->tab[h];
  12.     
  13.     return 0;
  14. }

sd_hash_end：未实现
  1. /**
  2.  * 获取hash表的最后一个元素容器
  3.  */
  4. extern sd_hash_iter_t* sd_hash_end(sd_hash_t* a_this)
  5. {
  6.     return 0;
  7. }

sd_hash_iter_next：
  1. /**
  2.  * 获取当前容器的下一个容器
  3.  */
  4. extern sd_hash_iter_t* sd_hash_iter_next(sd_hash_iter_t* a_this)
  5. {
  6.     int h;
  7. 	size_t i;
  8.     //参数检查并进行链表递进后返回
  9.     if (a_this == 0)		return 0;
  10.     if (a_this->__next != 0)	return a_this->__next;
  11.     //如果当前容器就是其容器指针的最后一个，那么要寻找到下一个容器指针的
  12.     //第一个容器进行返回
  13.     h = hindex(a_this->__hkey, a_this->hash->size);
  14.     
  15.     for (i = h + 1; i < a_this->hash->size; i++)
  16. 	if (a_this->hash->tab[i])
  17. 	    return a_this->hash->tab[i];
  18.     
  19.     return 0;
  20. }

sd_hash_iter_prev：
  1. /**
  2.  * 获取当前容器的上一个容器
  3.  */
  4. extern sd_hash_iter_t* sd_hash_iter_prev(sd_hash_iter_t* a_this)
  5. {
  6.     int			h, i;
  7.     sd_hash_iter_t*	p;
  8.     //参数验证，然后如果在当前容器指针的链表下存在前一个指针那么进行返回
  9.     if (a_this == 0)		return 0;
  10.     if (a_this->__prev != 0)	return a_this->__prev;
  11.     //如果当前容器就是该链表下的第一个，那么返回前一个容器指针的第一个有效容器
  12.     h = hindex(a_this->__hkey, a_this->hash->size);
  13.     
  14.     for (i = h - 1; i > 0; i--)
  15. 	for (p = a_this->hash->tab[i]; p; p = p->__next)
  16. 	    if (p->__next == 0)
  17. 		return p;
  18.     
  19.     return 0;
  20. }

sd_hash_iter_del：
  1. /**
  2.  * 删除一个容器，根据容器地址
  3.  */
  4. extern void sd_hash_iter_del(sd_hash_iter_t* a_this)
  5. {
  6.     if (a_this == 0) return;
  7.     //释放容器存放的数据
  8.     if (a_this->hash->ops->data_free != 0)
  9. 	a_this->hash->ops->data_free(a_this->data);
  10.     a_this->data	= 0;
  11.     //释放容器的key值内存
  12.     if (a_this->hash->ops->key_free != 0)
  13. 	a_this->hash->ops->key_free(a_this->key);
  14.     a_this->key		= 0;
  15.     //已经删除的即不再进行遍历了。
  16.     if (a_this->__foreach == 1) {
  17. 	a_this->__foreach = 0;
  18.         return;
  19.     }
  20.     //从链表中摘除
  21.     if (a_this->__next != 0) a_this->__next->__prev = a_this->__prev;
  22.     if (a_this->__prev != 0)
  23. 	a_this->__prev->__next = a_this->__next;
  24.     else
  25. 	a_this->hash->tab[hindex(a_this->__hkey, a_this->hash->size)] =
  26. 	    a_this->__next;
  27.     //减一数目
  28.     a_this->hash->nelem--;
  29.     //释放
  30.     free(a_this);
  31. }

sd_hash_hash_string：
  1. /**
  2.  * Hashes strings.计算key值
  3.  */
  4. extern unsigned int sd_hash_hash_string(const char* a_string)
  5. {
  6.     register unsigned int h;
  7.     //一个hash计算方法
  8.     for (h = 0; *a_string != '\0'; a_string++)
  9. 	h = *a_string + 31 * h;
  10.     
  11.     return h;
  12. }

一个示例程序
main.c
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "stack.h"
  5. #include "hash.h"
  6. #include "list.h"
  7. typedef struct test
  8. {
  9. 	char a[20];
  10. 	int b;
  11. 	int c;
  12. }test_t;
  13. static unsigned int print(void *data, void *p)
  14. {
  15. 	test_t *t = (test_t *)data;
  16. 	printf("a:%s b:%d c:%d\n",t->a, t->b, t->c);
  17. 	return 0;
  18. }
  21. unsigned int print_hash(void *a_key, void *a_data, void *a_userdata)
  22. {
  23. 	print(a_data, NULL);
  24. 	return 0;
  25. }
  27. int main()
  28. {
  29.     sd_hash_ops_t ops = {
  30. 	(void*) &sd_hash_hash_string,
  31. 	(void*) &strcmp,
  32. 	0, 0, 0, free
  33.     };
  34. 	
  35. 	sd_hash_t*hash = sd_hash_new(20, &ops);
  36. 	test_t *fir = malloc(sizeof(test_t));
  37. 	strcpy(fir->a,"zhang");
  38. 	fir->b = 10;
  39. 	fir->c = 20;
  40. 	sd_hash_add(hash, fir->a,fir);	
  41. 	test_t *sec = malloc(sizeof(test_t));
  42. 	strcpy(sec->a,"wang");
  43. 	sec->b = 20;
  44. 	sec->c = 30;
  45. 	sd_hash_add(hash, sec->a,sec);	
  46. 	test_t *third = malloc(sizeof(test_t));
  47. 	strcpy(third->a,"zhongguo");
  48. 	third->b = 30;
  49. 	third->c = 40;
  50. 	sd_hash_iter_t *iter = sd_hash_lookadd(hash, "zhongguo");	
  51. 	iter->data = third;
  53. 	int cnt = sd_hash_get_nelem(hash);
  54. 	printf("hash items is : %d\n",cnt);
  55. 	
  56. 	sd_hash_foreach(hash, print_hash, NULL);
  57. 	
  58. 	sd_hash_clear(hash);
  60. 	sd_hash_delete(hash);
  61. 	return 0;
  62. }








posted on 2017-08-28 11:35  cfzhang  阅读(200)  评论(0)  编辑  收藏  举报

导航