zoukankan      html  css  js  c++  java

  • 沉淀之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
",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
", sd_list_get_nelem(a_this));
    39. 	sd_list_delete(a_this);
    40. 	
    41. 	return 0;
    42. }
  • 相关阅读:
    1206 冲刺三
    1130持续更新
    1128项目跟进
    冲刺一1123（总结）
    冲刺一
    1117 新冲刺
    0621 第三次冲刺及课程设计
    0621回顾和总结
    实验四主存空间的分配和回收
    学习进度条
  • 原文地址：https://www.cnblogs.com/cfzhang/p/8c343c0bb8715ee6317b49f7aa62ebd4.html
Copyright © 2011-2022 走看看