018-结构体再进阶及深浅拷贝

moc

1、结构体嵌套一级、二级指针
知识点：1.对于创建内存空间的指针，不能向他指向的内存空间写值。
             2.malloc申请的空间在结束时需要手工释放，malloc怎么申请的 就要怎么释放；即只能拿到malloc返回的地址才能去释放。
             3. malloc申请的内存空间只能够被释放一次，不允许多次释放
熟悉下面这个模型（内存的申请、建立和释放方法）：

1. #include "stdio.h"
   
2. #include "stdlib.h"
   
3. #include "string.h"
   
4. 
   
5. // 结构体套一级、二级指针
   
6. struct Teacher
   
7. {
   
8.         char name[64];
   
9.         char *a_name;
   
10.         int age;  
    
11.         char **stuname;
    
12. };
    
13. 
    
14. //打印
    
15. void printfArray(struct Teacher *pArray, int count)
    
16. {
    
17.         int i = 0, j = 0;
    
18.         for (i = 0; i < count; i++)
    
19.         {
    
20.                 printf("\n%d  ", pArray[i].age);
    
21.                 printf("%s  ", pArray[i].name);
    
22.                 printf("%s  ", pArray[i].a_name);
    
23. 
    
24.                 for (j = 0; j < 3; j++)
    
25.                 {
    
26.                         printf("%s  ", pArray[i].stuname[j]);
    
27.                 }
    
28.         }
    
29. }
    
30. 
    
31. //排序
    
32. void sortArray(struct Teacher *pArray, int count)
    
33. {
    
34.         int i = 0, j = 0;
    
35.         struct Teacher tmp;
    
36.         for (i = 0; i < count; i++)
    
37.         {
    
38.                 for (j = i + 1; j < count; j++)
    
39.                 {
    
40.                         if (pArray[i].age < pArray[j].age)
    
41.                         {
    
42.                                 tmp = pArray[i];
    
43.                                 pArray[i] = pArray[j];
    
44.                                 pArray[j] = tmp;
    
45.                         }
    
46.                 }
    
47.         }
    
48. }
    
49. 
    
50. // 手工创建结构体数组
    
51. struct Teacher * createTArray1(int count)
    
52. {
    
53.         int i = 0, j = 0;
    
54.         struct Teacher*p1 = (struct Teacher *)malloc(count * sizeof(struct Teacher));
    
55.         if (p1 == NULL)
    
56.         {
    
57.                 return NULL;
    
58.         }
    
59. 
    
60.         for (i = 0; i < count; i++)
    
61.         {
    
62.                 memset(&p1[i], 0, sizeof(struct Teacher));  // 给申请的内存空间，每个字节赋0
    
63.                 memset(p1+i, '0', sizeof(struct Teacher)); // 和上面等价
    
64.                 p1[i].a_name = (char*)malloc(128 * sizeof(char));  // 开辟空间给a_name
    
65.                 memset(p1[i].a_name, 0, 128 * sizeof(char));   //为自己开辟的空间赋初值
    
66.                 //给stuname 手工打造一个二维内存空间
    
67.                 {
    
68.                         char **p2 = (char**)malloc(3 * sizeof(char*));
    
69.                         for (j = 0; j < 3; j++)
    
70.                         {
    
71.                                 p2[j] = malloc(128 * sizeof(char));
    
72.                                 memset(p2[j], 0, 128 * sizeof(char));
    
73.                         }
    
74.                         p1[i].stuname = p2;
    
75.                 }
    
76. 
    
77.         }
    
78.         return p1;
    
79. }
    
80. 
    
81. // 释放创建的空间
    
82. void freeTArray(struct Teacher * tArray, int num)
    
83. {
    
84.         int i = 0;
    
85.         if (tArray == NULL)
    
86.         {
    
87.                 return;
    
88.         }
    
89. 
    
90.         // 释放 为*a_name申请的空间
    
91.         for (i = 0; i < num; i++)
    
92.         {
    
93.                 if (tArray[i].a_name != NULL)   //为什么这里需要释放
    
94.                 {
    
95.                         free(tArray[i].a_name);
    
96.                 }
    
97. 
    
98.         // 释放 为**stuname申请 的手工二维空间
    
99.                 if (tArray[i].stuname != NULL)
    
100.                 {
     
101.                         int i1 = 0, j1 = 0;
     
102.                         for (i1 = 0; i1 < 3; i1++)
     
103.                         {
     
104.                                 if (tArray[i].stuname[i1] != NULL)
     
105.                                 {
     
106.                                         free(tArray[i].stuname[i1]);
     
107.                                 }
     
108.                         }
     
109.                         free(tArray[i].stuname);
     
110.                 }
     
111. 
     
112. // malloc怎么申请的 就要怎么释放；只能拿到malloc返回的地址才能去释放啦
     
113. 
     
114. /*                if (tArray[i].name != NULL)   //这个地方需要自己释放吗？(不需要，结构图是一块申请的，要一块释放)
     
115.                 {
     
116.                         free(tArray[i].name);
     
117.                 }
     
118. */               
     
119.         }
     
120.         if (tArray != NULL)
     
121.         {
     
122.                 free(tArray);
     
123.                 tArray = NULL; //垃圾话语
     
124.         }
     
125. }
     
126. 
     
127. void main()
     
128. {
     
129.         int i = 0, j = 0;
     
130.         struct Teacher *pArray = createTArray1(3);
     
131.         if (pArray == NULL)
     
132.         {
     
133.                 return;
     
134.         }
     
135. 
     
136. 
     
137. 
     
138.         //这里是结构体数组，tArray是首元素的地址，他的类型是首元素的类型，struct Teacher *;
     
139.         //tArray[0]是第一个结构体的变量名
     
140.         struct Teacher tArray[10];
     
141. 
     
142.         for (i = 0; i < 3; i++)
     
143.         {
     
144.                 printf("\n请输入age:");
     
145.                 scanf("%d", &pArray[i].age);
     
146.                 printf("\n请输入name:");
     
147.                 scanf("%s", pArray[i].name);
     
148.                 printf("\n请输入a_name:");
     
149.                 scanf("%s", pArray[i].a_name);
     
150. 
     
151.                 char **p2 = pArray[i].stuname;
     
152.                 for (j = 0; j < 3; j++)
     
153.                 {                       
     
154.                         printf("\n请输入学生的名字：");
     
155.                         scanf("%s", p2[j]);
     
156.                 }
     
157.         }
     
158.        
     
159.         printf("排序之前：\n");
     
160.         printfArray(pArray, 3);
     
161. 
     
162.         sortArray(pArray, 3);
     
163. 
     
164.         printf("\n排序之后：\n");
     
165.         printfArray(pArray, 3);
     
166. 
     
167.         freeTArray(pArray, 3);
     
168. 
     
169.         system("pause");
     
170. }

复制代码

2、深浅copy
        浅拷贝：指的是在进行结构体的拷贝时，由于结构体中有带内存块的指针变量，而拷贝时只是进行单纯的赋值操作，导致被复制的结构体所挂内存的丢失或没被创建。
        深拷贝：即在拷贝时避免的结构体内指针所挂内存块旳丢失或未创建。
浅拷贝容易造成内存的多次释放和内存的泄露。
代码示例：

1. #include "stdio.h"
   
2. #include "stdlib.h"
   
3. #include "string.h"
   
4. 
   
5. struct AdTeacher
   
6. {
   
7.         char name[64];
   
8.         char *a_name;
   
9.         int age;
   
10. };
    
11. 
    
12. // 手工创建结构体数组
    
13. struct AdTeacher * createTArray2(int count)
    
14. {
    
15.         int i = 0, j = 0;
    
16.         struct AdTeacher*p1 = (struct AdTeacher *)malloc(count * sizeof(struct AdTeacher));
    
17.         if (p1 == NULL)
    
18.         {
    
19.                 return NULL;
    
20.         }
    
21. 
    
22.         for (i = 0; i < count; i++)
    
23.         {
    
24.                 memset(&p1[i], 0, sizeof(struct AdTeacher));
    
25.                 memset(p1 + i, '0', sizeof(struct AdTeacher)); // 和上面等价
    
26.                 p1[i].a_name = (char*)malloc(128 * sizeof(char));  // 开辟空间给a_name
    
27.                 memset(p1[i].a_name, 0, 128 * sizeof(char));   //为自己开辟的空间赋初值
    
28.         }
    
29.         return p1;
    
30. }
    
31. 
    
32. // 释放创建的空间
    
33. void freeTArray2(struct AdTeacher * tArray, int num)
    
34. {
    
35.         int i = 0;
    
36.         if (tArray == NULL)
    
37.         {
    
38.                 return;
    
39.         }
    
40. 
    
41.         // 释放 为*a_name申请的空间
    
42.         for (i = 0; i < num; i++)
    
43.         {
    
44.                 if (tArray[i].a_name != NULL)   //为什么这里需要释放
    
45.                 {
    
46.                         free(tArray[i].a_name);
    
47.                 }
    
48.         }
    
49. 
    
50.         if (tArray != NULL)
    
51.         {
    
52.                 free(tArray);
    
53.                 tArray = NULL; //垃圾话语
    
54.         }
    
55. }
    
56. 
    
57. // 深拷贝
    
58. void deepCopy(struct AdTeacher *from, struct AdTeacher *to)
    
59. {
    
60.         memcpy(to, from, sizeof(struct AdTeacher));
    
61.         to->a_name = (char *)malloc(128);
    
62.         strcpy(to->a_name, from->a_name);
    
63. }
    
64. 
    
65. void main()
    
66. {
    
67.         int i = 0;
    
68.         //struct AdTeacher t1;
    
69.         //struct AdTeacher t2;
    
70.         struct AdTeacher* p1 = createTArray2(1);
    
71.         struct AdTeacher* p2 = createTArray2(1);
    
72. 
    
73. 
    
74. 
    
75.         printf("\n请输入age:");
    
76.         scanf("%d", &(p1[0].age));
    
77. 
    
78.         printf("\n请输入name:");
    
79.         scanf("%s", p1->name);
    
80. 
    
81.         printf("\n请输入a_name:");
    
82.         scanf("%s", p1[0].a_name);
    
83. 
    
84.         //浅拷贝
    
85. //        (*p2) = (*p1);  
    
86.         //编译器机械的=赋值，浅拷贝， 会导致p2和p1中的*a_name同时都指向p1中*a_name申请的内存空间
    
87.         //导致p1中*a_name在释放时释放两次，而p2中*a_name没有被释放。
    
88. 
    
89.         //自建函数来实现深拷贝
    
90.         deepCopy(p1, p2);
    
91. 
    
92.         freeTArray2(p1, 1);
    
93.         freeTArray2(p2, 1);
    
94.         system("pause");
    
95. }

复制代码