c语言提高学习笔记——02-c提高05day

最新推荐文章于 2024-11-10 12:28:40 发布

原创最新推荐文章于 2024-11-10 12:28:40 发布 · 298 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

本文深入探讨C语言中的结构体概念，包括结构体嵌套二级指针的应用、结构体偏移量计算、结构体内存对齐原理及实践。通过具体代码示例，详细解析结构体在内存中的布局和对齐规则，帮助读者掌握结构体的高级用法。

在学习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，转载请注明出处。