结构体中动态内存的管理（malloc和free）

C语言中内存的管理主要是依据malloc和free实现的，其中malloc主要是实现内存的分配，而free则是实现内存的释放。虽然这是我们已经很熟悉的，但是还是存在一些问题。特别是当结构体中存在指针的情况下，各种问题也就会展现出来。

其中最大的问题是：结构体中指针变量没有指向一块合法的内存空间，就对指针参数进行操作，这也是很多C语言程序员经常犯的错误。

简单的实例如下：

1. struct student
   
2. {
   
3.         char *name;
   
4.         int score;
   
5. }stu,*pstu;
   
6. 
   
7. int main()
   
8. {
   
9.         strcpy(stu.name,"Jimy");
   
10.         stu.score = 99;
    
11. 
    
12. 
    
13.         strcpy(pstu->name,"Jimy");
    
14.         pstu->score = 99;
    
15. }
16. 
    

这种代码是新手经常犯的错误，其中的主要错误是指针变量没有指向一块内存空间，其中包括ptest没有指向一块内存空间，同时结构体中的指针变量name也没有指向一块内存空间。

这种代码一般都会编译通过，但是运行过程中会发生新手编程经常出现的段错误Segmentation fault (core dumped)，我通过gdb对程序进行调试发现了存在的一些问题。其中stu.name中的内容是0x0，也就是地址0x0。这样我就知道了0x0为什么会发生段错误了，因为在Linux中进程都有一个独立的虚拟存储空间4G,但是其中在最底部的0x0是没有映射的，具体的参看进程的存储器映射关系。0x0并没有映射，这样发生段错误也就不奇怪了。

也就是说指针变量里存储的地址值并不是一个我们需要的值，为了指向一块内存空间，因此需要采用malloc分配一块内存空间。

改写上面的代码实现内存的分配。

1. int main()
   
2. {
   
3.         /*创建一块内存空间，并让stu.name指向这块内存空间*/
4.         stu.name = (char *)malloc(20*sizeof(char));
   
5.         /*实现字符串的复制过程*/
   
6.         strcpy(stu.name,"Jimy");
   
7.         stu.score = 99;
   
8. 
   
9.         /*创建一块内存空间，并让pstu指向这块内存空间*/
   
10.         pstu = (struct student *)malloc(sizeof(struct student));
    
11.         /*创建一块内存空间，并让pstu->name指向这块内存空间*/
    
12.         pstu->name = (char *)malloc(20*sizeof(char));
    
13.         /*实现字符串的复制过程*/
    
14.         strcpy(pstu->name,"Jimy");
    
15.         pstu->score = 99;
    
16.     
    
17.         return 0;
    
18. }

这样补充以后的代码就为指针变量添加了指向的对象，由于是采用malloc动态申请的存储空间，那么这段存储空间是分配在堆中，而不是在栈中，如果是在被调用函数中申请内存空间，那么在函数返回后该内存空间并不会释放。

1. Breakpoint 1, main () at TestStructPoint.c:21
2. 21 stu.name = (char *)malloc(20*sizeof(char));
3. Missing separate debuginfos, use: debuginfo-install glibc-2.12.90-17.i686
4. (gdb) p stu     ----stu中的内容
5. $1 = {name = 0x0, score = 0}
6. (gdb) p stu.name  ----stu.name其中的内容是0x0，也就是指向0x0
7. $2 = 0x0
8. (gdb) c
9. Continuing.
11. Breakpoint 2, main () at TestStructPoint.c:25
12. 25 strcpy(stu.name,"Jimy");
13. (gdb) p stu.name   -----stu.name其中的内容不再是0x0,而是一个地址值，该地值中的内容为空
14. $3 = 0x804a008 ""
15. (gdb) c
16. Continuing.
18. Breakpoint 3, main () at TestStructPoint.c:26
19. 26 stu.score = 99;
20. (gdb) p stu.name    -----stu.name中存储的地址的内容发生了变化。
21. $4 = 0x804a008 "Jimy"
22. (gdb) c
23. Continuing.
25. Breakpoint 4, main () at TestStructPoint.c:29
26. 29 pstu = (struct student *)malloc(sizeof(struct student));
27. (gdb) p pstu        ----pstu指向的地址也是0x0
28. $5 = (struct student *) 0x0
29. (gdb) c
30. Continuing.
32. Breakpoint 5, main () at TestStructPoint.c:32
33. 32 pstu->name = (char *)malloc(20*sizeof(char));
34. (gdb) p pstu    ----pstu指向的内存地址发生了改变，不再是0x0
35. $6 = (struct student *) 0x804a020
36. (gdb) c
37. Continuing.
39. Breakpoint 6, main () at TestStructPoint.c:35
40. 35 strcpy(pstu->name,"Jimy");
41. (gdb) p pstu
42. $7 = (struct student *) 0x804a020
43. (gdb) p pstu->name   ----pstu->name中的地址也不再是0x0,而是一个非零的地址值
44. $8 = 0x804a030 ""
45. (gdb) c
46. Continuing.
48. Breakpoint 7, main () at TestStructPoint.c:36
49. 36 pstu->score = 99;
50. (gdb) p pstu->name
51. $9 = 0x804a030 "Jimy"  ----pstu->name指向地址中的内容发生改变
52. (gdb) c
53. Continuing.
55. Program exited normally.

根据上面的调试可以知道，指针变量在定义过程中没有初始化为NULL，则指针变量指向的地址就是0x0,而在Linux中的进程虚拟存储器映射中地址0x0并没有映射，因此会出现错误。因此结构体中的指针变量一定要指向一块具体的存储空间之后才能进行相应的操作。同时其他的指针也必须指向相应的地址以后再操作。

但是分配完地址后还需要在相应操作结束后释放分配的存储器，不然会造成浪费，以及内存的泄漏。这也是很多程序员忘记完成的工作。

内存的释放采用free函数即可，free函数是将分配的这块内存与指针（malloc返回的指针）之间的所有关系斩断，指针变量P中存储的地址（这块内存的起始地址）值也没有发生变化，同时存储器中存储的内容也并没有发生改变，改变的只是指针对这块内存地址的所有权问题。但是该起始地址所在内存中的数据内容已经没法使用了,即时采用其他的指针也不能访问。如果下一次调用malloc函数可能会在刚才释放的区域创建一个内存空间，由于释放以后的存储空间的内容并没有改变(我是参考书上的，但我认为free后存储器中的内容是发生变化的，后面的调试可以说明这个问题，只是不知道发生什么变化，我也只是猜测，但是不要访问这个存储空间的内容是最安全的)，这样可能会影响后面的结果，因此需要对创建的内存空间进行清零操作（防止前面的操作影响后面），这通常采用memset函数实现，具体参看memset函数。还有指针变量P中存储的地址值并没有改变，由于指针P没有对这个地址的访问权限，程序中对P的引用都可能导致错误的产生，造成野指针，因此最后还需要将指针P指向NULL，避免野指针的产生。当然也需要对创建是否成功需要检测，但这里我暂时不考虑这些错误的处理。

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<string.h>
   
4. 
   
5. struct student
   
6. {
   
7.         char *name;
   
8.         int score;
   
9. }stu,*pstu;
   
10. 
    
11. 
    
12. int main()
    
13. {
    
14.         /*为name分配指向的一段内存空间*/
    
15.         stu.name = (char *)malloc(20*sizeof(char));
    
16.         memset(stu.name,0,20*sizeof(char));
    
17. 
    
18.         strcpy(stu.name,"Jimy");
    
19.         stu.score = 99;
    
20. 
    
21.         /*为pstu分配指向的一段内存空间*/
    
22.         pstu = (struct student *)malloc(sizeof(struct student));
    
23.         memset(pstu,0,sizeof(struct student));
    
24. 
    
25.         /*为name分配指向的一段内存空间*/
    
26.         pstu->name = (char *)malloc(20*sizeof(char));
    
27.         memset(pstu->name,0,20*sizeof(char));
    
28. 
    
29.         strcpy(pstu->name,"Jimy");
    
30.         pstu->score = 99;
    
31. 
    
32.         /*采用另外的指针访问分配的存储空间，测试内存中内容是否改变*/
    
33.         char *p = stu.name;
    
34.         char *p1 = (char *)0x804a008;//具体的地址值 
    
35.         char *ppstu = pstu->name;
    
36.         char *pp = (char *)0x804a030;//具体的地址值
    
37. 
    
38.         /*释放的顺序要注意，pstu->name必须在pstu释放之前释放，
39.          *如果pstu先释放，那么pstu->name就不能正确的访问。
    
40.         */
    
41.         free(pstu->name);
    
42.         free(stu.name);
    
43.         free(pstu);
    
44. 
    
45.         /*为了防止野指针产生*/
    
46.         pstu->name = NULL;
    
47.         stu.name = NULL;
    
48.         pstu = NULL;
    
49.         p = NULL;
    
50.         ppstu = NULL;
    
51. 
    
52.         return 0;
    
53. }

下面的全部是调试结果，根据调试结果说明问题：

2. (gdb) r
3. Starting program: /home/gong/program/cprogram/TestStructPoint 
4. 
   
5. Breakpoint 1, main () at TestStructPoint.c:14
6. 14stu.name = (char *)malloc(20*sizeof(char));
7. Missing separate debuginfos, use: debuginfo-install glibc-2.12.90-17.i686
8. (gdb) p stu
9. $1 = {name = 0x0, score = 0}
10. (gdb) p stu.name
11. $2 = 0x0
12. (gdb) c
13. Continuing.
14. 
    
15. Breakpoint 2, main () at TestStructPoint.c:17
16. 17strcpy(stu.name,"Jimy");
17. (gdb) p stu.name
18. $3 = 0x804a008 ""
19. (gdb) c
20. Continuing.
21. 
    
22. Breakpoint 3, main () at TestStructPoint.c:21
23. 21pstu = (struct student *)malloc(sizeof(struct student));
24. (gdb) p stu.name
25. $4 = 0x804a008 "Jimy"
26. (gdb) p stu
27. $5 = {name = 0x804a008 "Jimy", score = 99}
28. (gdb) p pstu
29. $6 = (struct student *) 0x0
30. (gdb) c
31. Continuing.
32. 
    
33. Breakpoint 4, main () at TestStructPoint.c:24
34. 24pstu->name = (char *)malloc(20*sizeof(char));
35. (gdb) p pstu
36. $7 = (struct student *) 0x804a020
37. (gdb) p pstu->name
38. $8 = 0x0
39. (gdb) c
40. Continuing.
41. 
    
42. Breakpoint 5, main () at TestStructPoint.c:27
43. 27strcpy(pstu->name,"Jimy");
44. (gdb) p pstu->name
45. $9 = 0x804a030 ""
46. (gdb) c
47. Continuing.
48. 
    
49. Breakpoint 6, main () at TestStructPoint.c:31
50. 31char *p = stu.name;
51. (gdb) p pstu->name
52. $10 = 0x804a030 "Jimy"
53. (gdb) p *pstu
54. $11 = {name = 0x804a030 "Jimy", score = 99}
55. (gdb) p p
56. $12 = 0x854ff4 "|M\205"
57. (gdb) c
58. Continuing.
59. 
    
60. Breakpoint 7, main () at TestStructPoint.c:32
61. 32char *p1 = (char *)0x804a008;//具体的地址值
62. (gdb) p p1
63. $13 = 0x855ca0 ""
64. (gdb) c
65. Continuing.
66. 
    
67. Breakpoint 8, main () at TestStructPoint.c:33
68. 33char *ppstu = pstu->name;
69. (gdb) p p1
70. $14 = 0x804a008 "Jimy"
71. (gdb) p ppstu
72. $15 = 0x855ca0 ""
73. (gdb) c
74. Continuing.
75. 
    
76. Breakpoint 9, main () at TestStructPoint.c:34
77. 34char *pp = (char *)0x804a030;//具体的地址值
78. (gdb) p ppstu
79. $16 = 0x804a030 "Jimy"
80. (gdb) p pp
81. $17 = 0x804826a "__libc_start_main"
82. (gdb) c
83. Continuing.
84. 
    
85. Breakpoint 10, main () at TestStructPoint.c:37
86. 37free(pstu->name);
87. (gdb) p pp
88. $18 = 0x804a030 "Jimy"
89. (gdb) p pstu->name
90. $19 = 0x804a030 "Jimy"
91. (gdb) c
92. Continuing.
93. 
    
94. Breakpoint 11, main () at TestStructPoint.c:38
95. 38free(stu.name);
96. (gdb) p pstu->name
97. $20 = 0x804a030 ""
98. (gdb) c
99. Continuing.
100. 
     
101. Breakpoint 12, main () at TestStructPoint.c:39
102. 39free(pstu);
103. (gdb) p stu.name
104. $21 = 0x804a008 "(\240\004\b"
105. (gdb) p pstu
106. $22 = (struct student *) 0x804a020
107. (gdb) p *pstu
108. $23 = {name = 0x804a030 "", score = 99}
109. (gdb) c
110. Continuing.
111. 
     
112. Breakpoint 13, main () at TestStructPoint.c:41
113. 41pstu->name = NULL;
114. (gdb) p *pstu
115. $24 = {name = 0x0, score = 99}
116. (gdb) p pstu->name
117. $25 = 0x0
118. (gdb) c
119. Continuing.
120. 
     
121. Breakpoint 14, main () at TestStructPoint.c:47
122. 47return 0;
123. (gdb) p p1
124. $26 = 0x804a008 "(\240\004\b"
125. (gdb) p pp
126. $27 = 0x804a030 ""
127. (gdb) p pstu
128. $28 = (struct student *) 0x0
129. (gdb) p pstu->name
130. Cannot access memory at address 0x0
131. (gdb) 

具体的调试过程说明了其中很多的问题，根据其中的结果可以知道，free结束以后指针变量P（malloc返回）中存储的地址值并没有改变，但是通过该地值已经不能访问之前的分配的存储空间。我采用其他的指针（直接赋值地址以及指针赋值）访问得到的结果也不是正确的值，虽然这不能说明地址中的数据改变了，但说明对释放以后的存储空间再通过其他方法访问不会得到正确的值，但是内存空间中存在值，并不一定是0，因此每一次malloc都清零是必要的。防止野指针也是非常必要的，减少程序错误的概率。

最后说明一下，链表作为结构体的衍生产物，链表的结构体中就有指针变量，因此一定草采用malloc等分配好内存块以后，再对链表进行操作，不然都会导致不同问题的产生。