内存分配函数的接口，log4c内部又重新的封装了一下，在内部实现上仍然是采用的系统内存分配的那一套调用接口。重新实现这么一套接口，应该是为了方便调试，保证易用性和稳定下有了提高。

    这个封装的内部在分配了之后对于返回值做了检查。

malloc.h

1. #ifndef __sd_malloc_h
2. #define __sd_malloc_h
4. #include <stddef.h>
5. #include <stdlib.h>
6. #include "defs.h"
8. /**
9. * @file malloc.h
10. */
12. __SD_BEGIN_DECLS
14. typedef void (*sd_malloc_handler_t)();
16. extern sd_malloc_handler_t sd_malloc_set_handler(void (*a_handler)());
18. #ifndef __SD_DEBUG__
20. extern void *sd_malloc(size_t n);
21. extern void *sd_calloc(size_t n, size_t s);
22. extern void *sd_realloc(void *p, size_t n);
23. extern char *sd_strdup (const char *__str);
25. #else
27. #define sd_malloc malloc
28. #define sd_calloc calloc
29. #define sd_realloc realloc
30. #define sd_strdup strdup
32. #endif
34. __SD_END_DECLS
36. #endif

    头文件中一样包含着一对__SD_BEGIN_DECLS和__SD_END_DECLS，以及头文件defs.h的包含。

使用typedef定义了一个函数类型：typedef void (*sd_malloc_handler_t)();

    标识

sd_malloc_handler_t代表一个函数类型，

用这个类型可以定义类似如下结构的函数变量：

    void test（）

然后是根据一个宏：__SD_DEBUG__作为编译开关进行选择两套内存申请函数，一个是用宏进行定义的接口，实际就是系统本身的内存操作接口。另一个是自行实现的一组函数：sd_malloc、sd_calloc、sd_realloc、sd_strdup。

malloc.c里面就是对于在debug模式下的时候所实现的头文件中声明的这一组函数。

malloc.c

1. #ifdef HAVE_CONFIG_H
2. #include "config.h"
3. #endif
4. #include <stdio.h>
6. #ifdef HAVE_UNISTD_H
7. #include <unistd.h>
8. #endif
10. #include <string.h>
11. #include <stdlib.h>
12. #include "error.h"
14. #if defined(__APPLE__)
15. # include <sys/time.h>
16. # include <crt_externs.h>
17. # define environ (*_NSGetEnviron())
18. #endif /* __APPLE__ */
20. typedef void (*sd_malloc_handler_t)();
22. static sd_malloc_handler_t handler = NULL;
24. static void *
25. fixup_null_alloc (n)
26. size_t n;
27. {
28. void* p = 0;
30. #ifdef HAVE_SBRK
31. static char* first_break = NULL;
33. if (n == 0)
34. p = malloc ((size_t) 1);
36. if (p == 0) {
37. extern char **environ;
38. size_t allocated;
40. if (first_break != NULL)
41. allocated = (char *) sbrk (0) - first_break;
42. else
43. allocated = (char *) sbrk (0) - (char *) &environ;
44. sd_error("\nCannot allocate %lu bytes after allocating %lu bytes\n",
45. (unsigned long) n, (unsigned long) allocated);
47. if (handler)
48. handler();
49. else {
50. sd_error("\n\tMemory exhausted !! Aborting.\n");
51. abort();
52. }
53. }
54. #endif
55. return p;
56. }
58. sd_malloc_handler_t
59. sd_malloc_set_handler(a_handler)
60. sd_malloc_handler_t a_handler;
61. {
62. sd_malloc_handler_t previous = handler;
64. handler = a_handler;
65. return previous;
66. }
68. /* Allocate N bytes of memory dynamically, with error checking. */
70. void *
71. sd_malloc (n)
72. size_t n;
73. {
74. void *p;
76. p = malloc (n);
77. if (p == 0)
78. p = fixup_null_alloc (n);
79. return p;
80. }
82. /* Allocate memory for N elements of S bytes, with error checking. */
84. void *
85. sd_calloc (n, s)
86. size_t n, s;
87. {
88. void *p;
90. p = calloc (n, s);
91. if (p == 0)
92. p = fixup_null_alloc (n * s);
93. return p;
94. }
96. /* Change the size of an allocated block of memory P to N bytes,
97. with error checking.
98. If P is NULL, run sd_malloc. */
100. void *
101. sd_realloc (p, n)
102. void *p;
103. size_t n;
104. {
105. if (p == 0)
106. return sd_malloc (n);
107. p = realloc (p, n);
108. if (p == 0)
109. p = fixup_null_alloc (n);
110. return p;
111. }
113. /* Return a newly allocated copy of STRING. */
115. char *
116. sd_strdup (string)
117. const char *string;
118. {
119. return strcpy (sd_malloc (strlen (string) + 1), string);
120. }

    其实每个函数的实现里面，都是先调用系统函数进行内存分配，当内存分配不成功的时候会调用fixup_null_alloc函数进行再次尝试。熟悉了ansi C的同学看着这里的函数的定义会觉得比较怪异，其实Ansi C之前的函数形式就是这样的（K&R C风格），Ansi C为了兼容性也实现支持这种格式。参数还需要再这里重新定义下；

    然后对于

fixup_null_alloc的实现着重的研究下，因为下面所有函数的实现在失败的时候都会去调用这个函数，然后另外还有一个函数就是sd_malloc_set_handler，我在log4c里面搜索了一下，这个函数没有被调用的地方，也没有文字性的说明，搞不懂到底是要做什么，所以暂时不进行分析。

    fixup_null_alloc函数的定义在上面的第二十五行到第五十六行。其中第二十八行到三十五行在传入参数为0的时候做了一次判断并根据判断进行调用系统函数进行内存的分配。接下来的三十六行到五十三行是利用sbrk系统调用获取而这里参数给的是0，可以利用这个调用获取当前program break的位置。然后进行计算，打印一下当前系统中内存的情况进行报错处理。

    至于为什么用sbrk (0) - first_break;或者用sbrk (0) - (char *) &environ;

    首先使用sbrk (0)能够知道当前系统中可用堆的结束的位置，然后static关键字声明的first_break在bss段的最后，两者相减就能得到一共有多少内存已经分配出去了。至于environ为什么，还没有理解。

    至于使用方式上就拿这一组当成系统的内存操作接口就可以了。示例程序就不啰嗦了。