Standard C Episode 9

 1 /*
 2  * 结构体
 3  * */
 4 #include <stdio.h>
 5 /*struct {
 6         int age;
 7         char gender;
 8         float height;
 9     } student;//声明（定义）无名结构体的同时定义了结构体变量student
10 */
11 /*struct student {
12         int age;
13         char gender;
14         float height;
15     } student;//声明（定义）结构体struct student的同时定义了结构体变量student
16 */
17 /*struct student {
18         int age;
19         char gender;
20         float height;
21     };
22 typedef struct student stu;//将结构体类型名称重定义为stu.自重定义所在位置起就可以使用stu代替struct student了
23 */
24 typedef struct {
25         int age;
26         char gender;
27         float height;
28     } stu;//将无名结构体的类型名称重定义为stu.自重定义所在位置起就可以使用stu这个无名结构体了
29 
30 
31 
32 int main()
33 {
34     /*
35     struct student {
36         int age;
37         char gender;
38         float height;
39     };
40     struct student student;//这里前一个student和struct和起来共同代表是一个结构体名称；后一个student是结构体变量名称;
41     */
42     /*
43     struct student {
44         int age;
45         char gender;
46         float height;
47     } student;//声明（定义）结构体struct student的同时定义了结构体变量student
48     */
49     /*
50     struct {
51         int age;
52         char gender;
53         float height;
54     } student;//声明（定义）无名结构体的同时定义了结构体变量student
55     */
56 
57 
58     stu student = {24, ‘E‘, 1.60f};
59     printf("年龄是%d\n", student.age);
60     printf("性别是%c\n", student.gender);
61     printf("身高是%.2f\n", student.height);
62 
63     return 0;
64 }

 1 /*
 2  * 结构体变量占存储区大小
 3  *
 4  * 计算机数据存储的对齐和补齐
 5  * 计算器要求数据所占存储空间的起始地址应该是数据本身大小整数倍
 6  * 对齐：变量的地址必须是变量大小的整数倍。这叫做数据对齐。double变量的地址只需要是4的整数倍就可以了。
 7  * 补齐：结构体大小必须是其中最大成员变量的大小的整数倍。
 8  * double变量大小按照4字节计算。为了保证这一点，有时需要在结构体变量后面加入一些浪费的字节。这叫做补齐。
 9  * 
10  * 数据对齐导致结构体中不同成员之间有空隙，结构体变量的大小并不是其中所有成员变量的大小之和。补齐导致结构体尾部加入了一些浪费字节。
11  *
12  *
13  * 计算机对内存的管理是分组的，四个字节一组，每一组开头的字节的地址肯定是4的整数倍，第三个字节是2的整数倍。数据不能跨组存放。但是双精度浮点型double例外，double可以跨组存放。
14  * 总结一下，可以得出数据所占空间的起始地址应该是数据本身大小的整数倍。
15  * */
16 #include <stdio.h>
17 typedef struct {
18     char ch;
19     char ch1;
20     int value;
21 } stru1;
22 
23 
24 int main()
25 {
26     printf("结构体stru1大小是%d\n", sizeof(stru1));
27 
28     return 0;
29 }

 1 /*
 2  * 结构体位域练习
 3  *
 4  * 声明结构体的时候可以使用位域限制某个成员变量所占的二进制位数，所有的定点数变量都可以使用位域
 5  *
 6  * */
 7 
 8 #include <stdio.h>
 9 typedef struct {
10     int gender:1;
11     int age:6;
12 }stru1;
13 
14 int main()
15 {
16     stru1 stru;
17     //printf("&(stru.age)是%p\n", &(stru.age));//有编译错误 error: cannot take address of bit-field ‘age‘
18     printf("大小是%d\n", sizeof(stru1));
19     return 0;
20 }

 1  
 2 /*
 3  * 高位高字节，低位低字节存放，俗称"小端存储方式"；
 4  * 低位高字节，高位低字节存放，俗称"大端存储方式"
 5  *
 6  * 以下程序可以迅速测试机器是那种存储方式
 7  * */
 8 
 9 #include <stdio.h>
10 
11 typedef union {
12     char ch[4];
13     int value;
14 } un;
15 
16 int main()
17 {
18     un u;
19     u.value = 0x12345678;
20     if (0x78 == u.ch[0]) {
21         printf("小端\n");
22     }
23     else {
24         printf("大端\n");
25     }
26     printf("ud 大小是%d\n", sizeof(u));
27 }

 1 /*
 2  * 枚举练习
 3  * */
 4 #include <stdio.h>
 5 
 6 main()
 7 {
 8     enum em {SPRING, SUMMER, AUTUMN, WINTER};
 9     /*
10      * const int SPRING = 0;
11      * const int SUMMER = 1;
12      * const int AUTUMN = 2;
13      * const int WINTER = 3;
14      *
15      * */
16     typedef enum em season;
17     printf("season大小是%d\n", sizeof(season));
18     printf("SPRING是%d\n", SPRING);
19     season s = SUMMER;
20     /* int s = 1;*/
21     printf("s是%d\n", s);
22 
23     
24 }

 1 /*
 2  * 枚举练习
 3  *
 4  * */
 5 #include <stdio.h>
 6 #define N 2
 7 enum sex {MAN, WOMAN};
 8 
 9 main()
10 {
11     enum sex sexs[N] = {MAN, MAN};
12     printf("sexs[0]是%d\n", sexs[0]);//输出0
13     printf("sexs[1]是%d\n", sexs[1]);//输出0
14     sexs[0] = WOMAN;//把整型数1放入sexs[0]
15     sexs[1] = 1u;//把整型数1放入sexs[1]
16     printf("sexs[0]是%d\n", sexs[0]);//输出1
17     printf("sexs[1]是%d\n", sexs[1]);//输出1
18     sexs[1] = -1;//把整型数-1放入sexs[1];编译器不报警告
19     printf("sexs[1]是%d\n", sexs[1]);//输出-1
20 
21 
22 }