沉淀之log4c的list

    log4c中对于链表也实现了一套，可以在src/sd/目录下找到有对应的list.c和list.h两个文件。直接贴代码和注释。
list.h
  2. #ifndef __sd_list_h
  3. #define __sd_list_h

  5. #include <stddef.h>
  6. #include "defs.h"
  8. __SD_BEGIN_DECLS
  10. /**
  11.  * 声明list类型，实际定义是在list.c文件里
  12.  */
  13. typedef struct __sd_list sd_list_t;
  14. /**
  15.  * 定义list中元素的结构，data应该是指向用户数据的指针，
  16.  * 双向链表
  17.  */
  18. struct __sd_list_iter {
  19.     void*			data;
  20.     struct __sd_list*		list;
  21.     struct __sd_list_iter*	__next;
  22.     struct __sd_list_iter*	__prev;
  23.     int				__foreach;
  24. };
  26.  /**
  27.  * 对于元素容器进行类型的定义
  28.  */
  29. typedef struct __sd_list_iter sd_list_iter_t;
  32.  /**
  33.  * foreach遍历时的回调函数类型
  34.  */
  35. typedef unsigned int (*sd_list_func_t)(void* a_data, void* a_userdata);
  38.  /**
  39.  * 新建一个链表
  40.  * @param a_capacity 初始化链表中容纳元素的数量
  41.  * @return 			 链表的入口指针.
  42.  */
  43. extern sd_list_t* sd_list_new(size_t a_capacity);
  45. /**
  46.  * 销毁一个链表
  47.  * @todo 需要一个回调函数来释放用户数据(尚未实现)
  48.  */
  49. extern void sd_list_delete(sd_list_t* a_this);
  51. /**
  52.  * 将用户数据插入到链表的头部
  53.  */
  54. extern sd_list_iter_t* sd_list_prepend(sd_list_t* a_this, void* a_data);
  56. /**
  57.  * 将用户数据插入到链表的尾部
  58.  */
  59. extern sd_list_iter_t* sd_list_append(sd_list_t* a_this, void* a_data);
  61. /**
  62.  * 在链表里查找用户数据是否存在
  63.  * @param a_data 	待查找数据
  64.  * @return 			找到的元素地址，或者NULL.
  65.  */
  66. extern sd_list_iter_t* sd_list_lookup(sd_list_t* a_this, void* a_data);
  68. /**
  69.  * 在链表里查找数据，如果没有找到就调用sd_list_add().将数据插入到链表里
  70.  * @param a_data	 待查找数据
  71.  * @return 			查找到的数据地址，或者NULL.
  72.  */
  73. extern sd_list_iter_t* sd_list_lookadd(sd_list_t* a_this, void* a_data);
  75. /**
  76.  * 将用户数据插入到链表里，如果该数据已经存在则返回数据的指针
  77.  * @warning 		元素会插入到链表的头部
  78.  * @param a_data 	带插入数据
  79.  * @return			返回插入的或者已存在的元素指针
  80.  */
  81. extern sd_list_iter_t* sd_list_add(sd_list_t* a_this, void* a_data);
  83. /**
  84.  * 用a_func从头遍历链表中的所有元素，直到返回一个非NULL的返回值，则
  85.  * 将用户数据插入到返回的数据前面
  86.  * @param a_func 排序函数
  87.  * @param a_data 待插入的用户数据
  88.  * @return 		 用户数据插入后所在的容器指针
  89.  */
  90. extern sd_list_iter_t* sd_list_sortadd(sd_list_t* a_this,
  91. 				       sd_list_func_t a_func,
  92. 				       void* a_data);
  94. /**
  95.  * 从链表里删除一个用户数据
  96.  * @param a_data 包含用户数据的容器地址
  97.  */
  98. extern int sd_list_del(sd_list_t* a_this, void* a_data);
  100. /**
  101.  * 清空一个链表
  102.  */
  103. extern void sd_list_clear(sd_list_t* a_this);
  105. /**
  106.  * 调用a_func从头遍历整个链表直到返回一个非0
  107.  * @param a_func 遍历回调函数
  108.  * @param a_data 传入到回调函数的一个用户数据
  109.  */
  110. extern void sd_list_foreach(sd_list_t* a_this, sd_list_func_t a_func,
  111. 			    void* a_userdata);
  113. /**
  114.  * 调用a_func从后向前遍历整个链表直到返回一个非0
  115.  * @param a_func 遍历回调函数
  116.  * @param a_data 传入到回调函数的用户数据
  117.  */
  118. extern void sd_list_rforeach(sd_list_t* a_this, sd_list_func_t a_func,
  119. 			     void* a_userdata);
  121. /**
  122.  * 获取链表中元素的个数
  123.  */
  124. extern size_t sd_list_get_nelem(sd_list_t* a_this);
  126. /**
  127.  * 获取链表中第一个容器
  128.  */
  129. extern sd_list_iter_t* sd_list_begin(sd_list_t* a_this);
  131. /**
  132.  * Gets the past-the-last-element iterator of the list.
  133.  * 函数定义未实现 
  134.  */
  135. extern sd_list_iter_t* sd_list_end(sd_list_t* a_this);
  137. /**
  138.  * 获取链表中最后一个元素
  139.  */
  140. extern sd_list_iter_t* sd_list_rbegin(sd_list_t* a_this);
  142. /**
  143.  * Gets the before-the-first-element iterator of the list.
  144.  * 函数定义未实现
  145.  */
  146. extern sd_list_iter_t* sd_list_rend(sd_list_t* a_this);
  148. /**
  149.  * 得到当前容器的下一个容器
  150.  */
  151. extern sd_list_iter_t* sd_list_iter_next(sd_list_iter_t* a_this);
  153. /**
  154.  * 得到当前容器的前一个容器
  155.  */
  156. extern sd_list_iter_t* sd_list_iter_prev(sd_list_iter_t* a_this);
  158. /**
  159.  * 从链表中删除一个容器
  160.  */
  161. extern void sd_list_iter_del(sd_list_iter_t* a_this);
  163. /**
  164.  * 创建一个新的容器并将数据插入到a_this前面
  165.  * @param a_data 放入到新建容器的数据
  166.  */
  167. extern sd_list_iter_t* sd_list_iter_insert(sd_list_iter_t* a_this,
  168. 					   void* a_data);
  170. __SD_END_DECLS
  172. #endif

list.h中声明的函数，是在list.c中进行了实现，其中声明的两个函数：
extern sd_list_iter_t* sd_list_end(sd_list_t* a_this);
extern sd_list_iter_t* sd_list_rend(sd_list_t* a_this);
功能与
extern sd_list_iter_t* sd_list_begin(sd_list_t* a_this);
extern sd_list_iter_t* sd_list_rbegin(sd_list_t* a_this);
重复，所以在list.c里面只进行定义了一个空的函数体，并没有进行实现。

以下是list.c中的内容：
  1. #include "list.h"
  2. #include "malloc.h"
  3. #include <stdlib.h>
  5. struct __sd_list {
  6.     sd_list_iter_t*	head;
  7.     sd_list_iter_t*	tail;
  8.     size_t 		nelem;
  9. };
    list.h中有一个typedef语句：typedef struct __sd_list sd_list_t;    将sd_list_t声明一下然后在这里进行实际的结构体的定义，这样下面的函数声明中就可以使用这个sd_list_t进行参数或者返回值的声明了。并且只要引用了list.h就可以使用sd_list_t来进行定义自己的链表句柄。这样可以比较完美的实现结构体的隐藏同时还能比较容易使用。
    从这里就知道了整个链表的结构是什么样的了。具体的可以参考图一：

图一：链表的整体结构图
sd_list_new：
  1. extern sd_list_t* sd_list_new(size_t a_capacity)
  2. {
  3.     sd_list_t* this;
  4.    	//申请内存，并初始化。实际上calloc分配的就是初始化了的内存。
  5.     this	= sd_calloc(1, sizeof(sd_list_t));
  6.     this->head	= 0;
  7.     this->tail	= 0;
  8.     this->nelem	= 0;
  9.     return this;
  10. }
sd_list_prepend：
  1. extern sd_list_iter_t* sd_list_prepend(sd_list_t* a_this, void* a_data)
  2. {
  3. 	//定义一个容器，参数有效性判断。并进行容器内存分配和检查
  4.     sd_list_iter_t* i;
  5.     
  6.     if (! a_this) return 0;
  7.     
  8.     if ((i = sd_calloc(1, sizeof(*i))) == 0)
  9. 	return 0;
  10.     //填充容器，用户数据，链表等。
  11.     i->list		= a_this;
  12.     i->data		= a_data;
  13.     i->__prev		= 0;
  14.     i->__next		= a_this->head;
  15.     a_this->head	= i;
  16.     //接通后面的链表，否则设置链表的tail指针的指向
  17.     if (i->__next)
  18. 	i->__next->__prev	= i;
  19.     else
  20. 	a_this->tail		= i;
  21.     //增加元素计数器
  22.     a_this->nelem++;
  23.     
  24.     return i;
  25. }

sd_list_append：
  1. extern sd_list_iter_t* sd_list_append(sd_list_t* a_this, void* a_data)
  2. {
  3.     sd_list_iter_t* i;
  4.     
  5.     if (! a_this) return 0;
  6.     //定义一个容器，参数有效性判断。并进行容器内存分配和检查
  7.     if ((i = sd_calloc(1, sizeof(*i))) == 0)
  8. 	return 0;
  9.     //填充容器，用户数据，链表等。
  10.     i->list		= a_this;
  11.     i->data		= a_data;
  12.     i->__prev		= a_this->tail;
  13.     i->__next		= 0;
  14.     a_this->tail	= i;
  15.     //链接前面的链表或者设置链表的head指针
  16.     if (i->__prev)
  17. 	i->__prev->__next	= i;
  18.     else
  19. 	a_this->head		= i;
  20.     //计数器加一
  21.     a_this->nelem++;
  22.     
  23.     return i;
  24. }

sd_list_delete:
  1. extern void sd_list_delete(sd_list_t* a_this)
  2. {
  3.     sd_list_iter_t *a_next;
  4.     sd_list_iter_t *a_current;
  5.  
  6.      if (!a_this)
  7. 	return;
  8. 	//释放所有的容器
  9.     /* Free the iterators */
  10.     if (a_this->nelem > 0){
  11. 	a_current = a_this->head;
  12. 	do {
  13. 	    a_next = a_current->__next;
  14. 	    free(a_current);
  15. 	    a_current = a_next;
  16. 	} while (a_current);
  17.     }
  18. 	//释放链表 句柄
  19.     free(a_this);
  20. }

sd_list_clear:
  1. extern void sd_list_clear(sd_list_t* a_this)
  2. {
  3.     a_this->head    = 0;
  4.     a_this->tail    = 0;
  5.     a_this->nelem   = 0;
  6. }

sd_list_get_nelem:
  1. extern size_t sd_list_get_nelem(sd_list_t* a_this)
  2. {
  3.     return (a_this ? a_this->nelem : 0);
  4. }

sd_list_begin:
  1. extern sd_list_iter_t* sd_list_begin(sd_list_t* a_this)
  2. {
  3.     return (a_this ? a_this->head : 0);
  4. }

sd_list_rbegin:
  1. extern sd_list_iter_t* sd_list_rbegin(sd_list_t* a_this)
  2. {
  3.     return (a_this ? a_this->tail : 0);
  4. }

sd_list_lookup:
  1. extern sd_list_iter_t* sd_list_lookup(sd_list_t* a_this, void* a_data)
  2. {
  3.     sd_list_iter_t* i;
  4.     
  5.     if (! a_this) return 0;
  6.     //遍历直到找到数据地址与用户传入的地址相同，返回容器地址
  7.     for (i = a_this->head; i; i = i->__next)
  8. 	if (a_data == i->data)
  9. 	    return i;
  10.     
  11.     return 0;
  12. }

sd_list_add：
  1. extern sd_list_iter_t* sd_list_add(sd_list_t* a_this, void* a_data)
  2. {
  3.     sd_list_iter_t* i;
  4.     
  5.     if (! a_this) return 0;
  6.     //新建一个容器并分配内存检查    
  7.     if ((i = sd_calloc(1, sizeof(*i))) == 0)
  8. 	return 0;
  9.     //填充
  10.     i->data		= a_data;
  11.     i->list		= a_this;    
  12.     i->__next		= a_this->head;
  13.     i->__prev		= 0;
  14.     a_this->head	= i;
  15.     //插入首部
  16.     if (i->__next) i->__next->__prev	= i;
  17.     if (!a_this->tail) a_this->tail	= i;
  18.     //计数器加一
  19.     a_this->nelem++;
  20.     
  21.     return i;
  22. }

sd_list_lookadd：
  1. extern sd_list_iter_t* sd_list_lookadd(sd_list_t* a_this, void* a_data)
  2. {
  3.     sd_list_iter_t* i;
  4.     
  5.     if (! a_this) return 0;
  6.     //调用sd_list_lookup，或者就插入并返回
  7.     if ((i = sd_list_lookup(a_this, a_data)) != 0)
  8.         return i;
  10.     return sd_list_add(a_this, a_data);
  11. }

sd_list_iter_insert：
  1. extern sd_list_iter_t* sd_list_iter_insert(sd_list_iter_t* a_this,
  2. 					   void* a_data)
  3. {
  4.     sd_list_iter_t* i;
  5.     
  6.     if (! a_this) return 0;
  7.     //如果錫_this就是头节点那么就头插
  8.     if (a_this->list->head == a_this)
  9. 	return sd_list_prepend(a_this->list, a_data);
  10.     //申请内存，填充后插入到a_this之前
  11.     if ((i = sd_calloc(1, sizeof(*i))) == 0)
  12. 	return 0;
  13.     
  14.     i->data			= a_data;
  15.     i->list			= a_this->list;
  16.     i->__prev			= a_this->__prev;
  17.     i->__next			= a_this;
  18.     
  19.     /* CAUTION: always exists since a_this is not the head */
  20.     a_this->__prev->__next	= i;    
  21.     a_this->__prev		= i;
  22.     //计数器加一
  23.     a_this->list->nelem++;
  24.     
  25.     return i;
  26. }

sd_list_sortadd：
  1. extern sd_list_iter_t* sd_list_sortadd(sd_list_t* a_this,
  2. 				       sd_list_func_t a_func, void* a_data)
  3. {
  4.     sd_list_iter_t* i;
  5.     //参数检查
  6.     if (! a_this || ! a_func) return 0;
  7.      //从头遍历直到找到一个大于当前用户数据的位置
  8.     for (i = a_this->head; i; i = i->__next)
  9. 	if ((*a_func)(i->data, a_data) > 0)
  10. 	    break;
  11.     //如果不是最后的位置，那么插入新节点到a_data之前。否则添加在最后
  12.     if (i)
  13. 	return sd_list_iter_insert(i, a_data);
  14.     else
  15. 	return sd_list_append(a_this, a_data);
  16. }

sd_list_iter_del：
  1. extern void sd_list_iter_del(sd_list_iter_t* a_this)
  2. {
  3.     if (!a_this)
  4. 	return;
  5.     
  6.     if (a_this->__foreach == 1) {
  7. 	a_this->__foreach = 0;
  8. 	return;
  9.     }
  10.     //向后接通
  11.     if (a_this->__next)
  12. 	a_this->__next->__prev = a_this->__prev;
  13.     else
  14. 	a_this->list->tail = a_this->__prev;
  15. 	//向前接通
  16.     if (a_this->__prev)
  17. 	a_this->__prev->__next = a_this->__next;
  18.     else
  19. 	a_this->list->head = a_this->__next;
  20.     //计数器减一
  21.     a_this->list->nelem--;
  22.     //释放当前数据
  23.     free(a_this);
  24. }

sd_list_del：
  1. extern int sd_list_del(sd_list_t* a_this, void* a_data)
  2. {
  3.     sd_list_iter_t* i;
  4.     
  5.     if (!a_this)
  6. 	return -1;
  7.     //遍历直到找到这个数据
  8.     for (i = a_this->head; i; i = i->__next)
  9. 	if (a_data == i->data)
  10. 	    break;
  11.     //如果没找到
  12.     if (!i)
  13. 	return -1;
  14.     //删除这个元素
  15.     sd_list_iter_del(i);
  16.     return 0;
  17. }

sd_list_foreach：
  1. extern void sd_list_foreach(sd_list_t* a_this, sd_list_func_t a_func,
  2. 			    void* a_userdata)
  3. {
  4.     sd_list_iter_t* i;
  5.     sd_list_iter_t* j;
  6.     
  7.     if (!a_this || !a_func)
  8. 	return;
  9. 	//从头到尾遍历整个链表
  10.     for (i = a_this->head; i; i = j) 
  11. 	{
  12. 		int ret;
  13. 		
  14. 		i->__foreach	= 1;
  15. 		ret		= (*a_func)(i->data, a_userdata);
  16. 		j		= i->__next;
  17. 		
  18. 		if (i->__foreach == 0)
  19. 		    sd_list_iter_del(i);
  20. 		else
  21. 		    i->__foreach = 0;
  22. 		
  23. 		if (ret) return;
  24.     }
  25. }

sd_list_rforeach：
  1. extern void sd_list_rforeach(sd_list_t* a_this, sd_list_func_t a_func,
  2. 			     void* a_userdata)
  3. {
  4.     sd_list_iter_t* i;
  5.     sd_list_iter_t* j;
  6.     
  7.     if (!a_this || !a_func)
  8. 	return;
  10.     for (i = a_this->tail; i; i = j) {
  11. 	int ret;
  12. 	
  13. 	i->__foreach	= 1;
  14. 	ret		= (*a_func)(i->data, a_userdata);
  15. 	j		= i->__prev;
  16. 	
  17. 	if (i->__foreach == 0)
  18. 	    sd_list_iter_del(i);
  19. 	else
  20. 	    i->__foreach = 0;
  21. 	
  22. 	if (ret) return;
  23.     }
  24. }

sd_list_iter_next：
  1. extern sd_list_iter_t* sd_list_iter_next(sd_list_iter_t* a_this)
  2. {
  3.     return (a_this ? a_this->__next : 0);
  4. }

sd_list_iter_prev：
  1. extern sd_list_iter_t* sd_list_iter_prev(sd_list_iter_t* a_this)
  2. {
  3.     return (a_this ? a_this->__prev : 0);
  4. }
   
    一个简单的样例测试程序如下：
main.c
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "stack.h"
  4. #include "list.h"
  5. typedef struct test
  6. {
  7. 	int a;
  8. 	int b;
  9. 	int c;
  10. }test_t;
  11. static unsigned int print(void *data, void *p)
  12. {
  13. 	test_t *t = (test_t *)data;
  14. 	printf("a:%d b:%d c:%d\n",t->a, t->b, t->c);
  15. 	return 0;
  16. }
  18. int main()
  19. {
  20. 	sd_list_t* a_this = sd_list_new(24);
  21. 	test_t *t3 = malloc(sizeof(test_t));
  22. 	t3->a = 3;
  23. 	t3->b = 4;
  24. 	t3->c = 5;		
  25. 	sd_list_prepend(a_this, t3);
  26. 	test_t *t1 = malloc(sizeof(test_t));
  27. 	t1->a = 1;
  28. 	t1->b = 2;
  29. 	t1->c = 3;	
  30. 	sd_list_prepend(a_this, t1);
  31. 	test_t *t2 = malloc(sizeof(test_t));
  32. 	t2->a = 2;
  33. 	t2->b = 3;
  34. 	t2->c = 4;		
  35. 	sd_list_prepend(a_this, t2);
  37.  	sd_list_foreach(a_this, print, NULL);
  38. 	printf("remains in list:%d\n", sd_list_get_nelem(a_this));
  39. 	sd_list_delete(a_this);
  40. 	
  41. 	return 0;
  42. }







posted on 2017-08-28 11:43  cfzhang  阅读(178)  评论(0)    收藏  举报

导航