zoukankan      html  css  js  c++  java

  • 沉淀之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 != ''; 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
",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
",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. }
  • 相关阅读:
    【例题 6-12 UVA
    【例题 6-11 UVA-297】Quadtrees
    【例题 6-10 UVA
    SpringMVC表单验证器
    Spring MVC常用注解
    什么是Spring Boot？
    什么是Kotlin？Java的替代语言？
    阿里Druid连接池的坑。。
    常见的3种Class级别的错误
    阿里巴巴，排行前10的开源项目
  • 原文地址：https://www.cnblogs.com/cfzhang/p/12a02b43f08412c685a32aa489b59579.html
Copyright © 2011-2022 走看看