在学习c语言提高总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。
02-c提高05day
目录：
1、以前课程问题复习
2、结构体嵌套二级指针
3、结构体偏移量
4、结构体字节对齐
（1）内存对齐
1）内存对齐原因
2）如何内存对齐
（2）练习
1、以前课程问题复习
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #include<string.h>
4 #include<stdlib.h>
5
6 void test01()
7 {
8 char* arr[] = {"aaa", "bbb", "ccc", "ddd"};//等价于下边
9 #if 0
10 char* p1 = "aaa";
11 char* p2 = "bbb";
12 char* p3 = "ccc";
13 char* p4 = "ddd";
14 char* arr[] = {p1, p2, p3, p4};
15 #endif
16 //返回的是首元素的地址
17 char** arr = malloc(sizeof(char*) * 4);
18
19 //错误写法，原因放不下
20 //char** arr = {"aaa","bbb","ccc","ddd"};
21 }
22
23 void printArray1(int* arr, int len){}
24 void printArray2(int(*arr)[3], int len){}
25 void printArray2(char** arr, int len){}
26 void test02()
27 {
28 //除了sizeof对数组名取地址这两种情况下，其他任何情况下数组名都是指向首元素的指针
29 int arr1[10]={0};//arr1是什么类型？int*类型
30 printArray1(arr1,10);
31
32 int arr2[3][3] = {
33 {1,2,3},
34 {4,5,6},
35 {7,8,9}
36 };//arr2是什么类型？int(*)[3]
37 printArray2(arr2,3);
38
39 char* arr3[] = {"aaa","bbb","ccc"};//arr3是什么类型？char**类型
40 printArray3(arr3,3);
41
42 char** arr4[3];//arr4是什么类型？char***
43 }
44
45 //数组指针
46 void test03()
47 {
48 int arr[10];
49 //第一种方法
50 typedef int (ARRAY_TYPE)[10];
51 ARRAY_TYPE *p1 = &arr;
52 //第二种方法
53 typedef int (ARRAY_POINTER_TYPE)[10];
54 ARRAY_POINTER_TYPE p2 = &arr;
55 //第三种方法
56 int(*p3)[10] = &arr;
57 }
58
59 //结构体赋值
60 struct Person
61 {
62 char name[64];
63 int age;
64 };
65 //只要结构体内部不涉及到指针，并且指针指向堆内存，那么使用默认操作是没有问题的
66 struct Teacher
67 {
68 char* name;
69 int age;
70 };
71
72 void test04()
73 {
74 //结构体赋值
75 struct Teacher p1, p2;
76 //p1 = p2;//会导致两个问题!
77 }
78
79
80 int main(){
81
82 test01();
83
84 system("pause");
85 return EXIT_SUCCESS;
86 }
2、结构体嵌套二级指针
练习：
内存模型图如下：
代码如下：
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #include<string.h>
4 #include<stdlib.h>
5
6 struct Teacher
7 {
8 char* name;
9 char** students;
10 };
11
12 int allocateSpace(struct Teacher*** temp)
13 {
14 if(NULL == temp)
15 {
16 //错误码，不同错误码表示不同错误
17 return -1;
18 }
19
20 struct Teacher** ts = malloc(sizeof(struct Teacher*) * 3);
21 for(int i = 0; i < 3; ++i)
22 {
23 //给老师结构体指针分配空间
24 ts[i] = malloc(sizeof(struct Teacher));
25
26 //给老师名字分配空间
27 ts[i]->name = malloc(sizeof(char) * 64);
28 sprintf(ts[i]->name, "Teacher_%d", i + 1);
29
30 //给学生指针分配内存
31 ts[i]->students = malloc(sizeof(char*) * 4);
32 for(int j = 0; j < 4; ++j)
33 {
34 ts[i]->students[j] = malloc(sizeof(char) * 64);
35 sprintf(ts[i]->students[j], "%s_Stu_%d",ts[i]->name, j + 1);
36 }
37 }
38 *temp = ts;
39 return 0;
40 }
41
42 void printTeachers(struct Teacher** teachers)
43 {
44 if(NULL == teachers)
45 {
46 return;
47 }
48 for(int i = 0; i < 3; ++i)
49 {
50 printf("%s\n", teachers[i]->name);
51 for(int j = 0; j < 4; ++j)
52 {
53 printf(" %s\n", teachers[i]->students[j]);
54 }
55 }
56 }
57
58 //释放内存
59 void freeSpace(struct Teacher** teachers)
60 {
61 if(NULL == teachers)
62 {
63 return;
64 }
65 for(int i = 0; i < 3; ++i)
66 {
67 if(teachers[i] == NULL)
68 {
69 continue;
70 }
71 if(teachers[i]->name != NULL)
72 {
73 free(teachers[i]->name);
74 teachers[i]->name = NULL;
75 }
76 for(int j = 0; j < 4; ++j)
77 {
78 if(teachers[i]->students[j] != NULL)
79 {
80 free(teachers[i]->students[j]);
81 teachers[i]->students[j] = NULL;
82 }
83 }
84 free(teachers[i]->students);
85 teachers[i]->students = NULL;
86
87 free(teachers[i]);
88 teachers[i] = NULL;
89
90 }
91 free(teachers);
92 teachers = NULL;
93 }
94
95
96 void test()
97 {
98 struct Teacher** teachers = NULL;
99
100 int ret = 0;
101 ret = allocateSpace(&teachers);
102 if(ret < 0)
103 {
104 printf("allocateSpace函数调用出错!\n");
105 return;
106 }
107 //打印老师及其学生信息
108 printTeachers(teachers);
109
110 //释放内存
111 freeSpace(teachers);
112 teachers = NULL;
113 }
114
115 int main(){
116
117 test();
118
119 system("pause");
120 return EXIT_SUCCESS;
121 }
3、结构体偏移量
练习：
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #include<string.h>
4 #include<stdlib.h>
5 #include<stddef.h>//计算结构体成员的偏移量
6
7 struct A
8 {
9 char a1;
10 int a2;
11 };
12
13 void test01()
14 {
15 struct A a = {'b', 20};
16 printf("A.a2:%d\n",*(int*)((char*)&a + offsetof(struct A, a2)));
17 printf("A.a2:%d\n", *((int*)&a + 1));
18 }
19
20 struct C
21 {
22 int a;
23 double b;
24 };
25 struct B
26 {
27 char a;
28 int b;
29 struct C c;
30 };
31
32 void test02()
33 {
34 struct B b = {'a', 20, 30, 3.14};
35 int off1 = offsetof(struct B, c);
36 int off2 = offsetof(struct C, b);
37
38 printf("%d\n", *(double*)(((char*)&b + off1) + off2));
39 printf("%d\n", &(b.c.b);//判断b地址是否正确
40 printf("%d\n", ((struct c*)((char*)&b + off1))->b);
41 }
42
43
44 int main(){
45
46 test01();
47
48 system("pause");
49 return EXIT_SUCCESS;
50 }
4、结构体字节对齐
在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。
从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列，而不是简单地顺序排列，这就是内存对齐。
（1）内存对齐
1）内存对齐原因
我们知道内存的最小单元是一个字节，当cpu从内存中读取数据的时候，是一个一个字节读取，所以内存对我们应该是入下图这样：
但是实际上cpu将内存当成多个块每次从内存中读取一个块这个块的大小可能是2、4、8、16等，
那么下面，我们来分析下非内存对齐和内存对齐的优缺点在哪？
内存对齐是操作系统为了提高访问内存的策略。操作系统在访问内存的时候，每次读取一定长度（这个长度是操作系统默认的对齐数，或者默认对齐数的整数倍）。如果没有对齐，为了访问一个变量可能产生二次访问。
至此大家应该能够简单明白，为什么要简单内存对齐？
·提高存取数据的速度。比如有的平台每次都是从偶地址处读取数据，对于一个int型的变量，若从偶地址单元处存放，则只需一个读取周期即可读取该变量；但是若从奇地址单元处存放，则需要2个读取周期读取该变量。
·某些平台只能在特定的地址处访问特定类型的数据，否则抛出硬件异常给操作系统。
2）如何内存对齐
■对于标准数据类型，它的地址只要是它的长度的整数倍。
■对于非标准数据类型，比如结构体，要遵循一下对齐原则：
1.数组成员对齐规则。第一个数组成员应该放在offset为0的地方，以后每个数组成员应该放在offset为min（当前成员的大小，#pargama pack(n))整数倍的地方开始（比如int在32位机器为4字节，#pargama pack(2)，那么从2的倍数地方开始存储）。
2.结构体总的大小，也就是sizeof的结果，必须是min（结构体内部最大成员，#pargama pack(n))的整数倍，不足要补齐。
3.结构体做为成员的对齐规则。如果一个结构体B里嵌套另一个结构体A，还是以最大成员类型的大小对齐，但是结构体A的起点为A内部最大成员的整数倍的地方。（struct B里存有structA，A里有char，int，double等成员，那A应该从8的整数倍开始存储。），结构体A中的成员的对齐规则仍满足原则1、原则2。
手动设置对齐模数：
■#pragma pack(show)
显示当前 packing alignment的字节数，以warning message的形式被显示。
■#pragma pack(push)
将当前指定的packing alignment数组进行压栈操作，这里的栈是the internal compiler stack，同事设置当前的packing alignment为n；如果n没有指定，则将当前的packing alignment数组压栈。
■#pragma pack(pop)
从internal compiler stack 中删除最顶端的reaord；如果没有指定n,则当前栈顶record即为新的packing alignement数值；如果指定了n，则n成为新的packing alignment值。
■#pragma pack(n)
指定packing的数值以字节为单位缺省数值是8合法的数值分别是1,2,4,8,16。
（2）练习：
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #include<string.h>
4 #include<stdlib.h>
5 #include<stddef.h>//计算结构体成员的偏移量
6
7 //1.第一个元素偏移量是0
8 //2.从第二个元素开始计算偏移量，20
9 //3.计算整体偏移，找最大成员（double）为8，最终大小必须是8的倍数，大于20最小的8的倍数是24
10 struct Student{
11 int a;//0-3
12 char b;//1和8取最小，放到4
13 double c;//8和8取最小，放到8-15
14 float d;//4和8取最小，放到16-19
15 };
16
17 void test01()
18 {
19 printf("%d\n", sizeof(struct Student));
20 }
21
22 int main(){
23
24 test01();
25
26 system("pause");
27 return EXIT_SUCCESS;
28 }
深入理解：（结构体嵌套结构体）
1 #pragma pack(4)
2
3 typedef struct _STUDENT{
4 int a;
5 char b;
6 double c;
7 float d;
8 }Student;
9
10 typedef struct _STUDENT2{
11 char a;
12 Student b;
13 double c;
14 }Student2;
15
16 void test01(){
17 //Student
18 //a从偏移量0位置开始存储
19 //b从4位置开始存储
20 //c从8位置开始存储
21 //d从12位置开存储
22 //所以Student内部对齐之后的大小为20，整体对齐，整体为最大类型的整数倍也就是8的整数倍为24
23 printf("sizeof Student:%d\n",sizeof(Student));
24
25 //Student2
26 //a从偏移量为0位置开始8
27 //b从偏移量为Student内部最大成员整数倍开始，也就是8开始24
28 //c从8的整数倍地方开始，也就是32开始
29 //所以结构体Sutdnet2内部对齐之后的大小为：40，由于结构体中最大成员为8，必须为8的整数倍所以大小为40
30 printf("sizeof Student2:%d\n",sizeof(Student2));
31 }
在学习c语言提高总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。
扫一扫
560
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
