1 /*
 2  数组：只能由多个相同类型的数据构成
 3
 4  结构体：可以由多个不同类型的数据构成
 5  */
 6 #include <stdio.h>
 7
 8 int main()
 9 {
10     //int ages[3] = {[2] = 10, 11, 27};
11
12
13     //int ages[3] = {10, 11, 29};
14
15     // 1.定义结构体类型
16     struct Person
17     { // 里面的3个变量，可以称为是结构体的成员或者属性
18         int age; // 年龄
19         double height; // 身高
20         char *name; // 姓名
21     };
22
23     // 2.根据结构体类型，定义结构体变量
24     struct Person p = {20, 1.55, "jack"};
25     p.age = 30;
26     p.name = "rose";
27
28     printf("age=%d, name=%s, height=%f\n", p.age, p.name, p.height);
29
30     /* 错误写法
31     struct Person p2;
32     p2 = {30, 1.67, "jake"};
33     */
34
35     struct Person p2 = {.height = 1.78, .name="jim", .age=30};
36     //p2.age = 25;
37
38     return 0;
39 }

 1 #include <stdio.h>
 2 int main()
 3 {
 4
 5
 6     return 0;
 7 }
 8
 9 // 补齐算法
10 void test1()
11 {
12     struct Student
13     {
14         int age;// 4个字节
15
16         char a;
17
18         //char *name; // 8个字节
19     };
20
21     struct Student stu;
22     //stu.age = 20;
23     //stu.name = "jack";
24     // 补齐算法（对齐算法）
25     // 结构体所占用的存储空间 必须是 最大成员字节数的倍数
26
27     int s = sizeof(stu);
28     printf("%d\n", s);
29 }
30
31 // 结构体内存细节
32 void test()
33 {
34     // 1.定义结构体类型(并不会分配存储空间)
35     struct Date
36     {
37         int year;
38         int month;
39         int day;
40     };
41
42     // 2.定义结构体变量（真正分配存储空间）
43     struct Date d1 = {2011, 4, 10};
44
45
46     struct Date d2 = {2012, 8, 9};
47
48     // 会将d1所有成员的值对应地赋值给d2的所有成员
49     d2 = d1;
50     d2.year = 2010;
51
52     printf("%d - %d - %d\n", d1.year, d1.month, d1.day);
53
54     printf("%d - %d - %d\n", d2.year, d2.month, d2.day);
55     /*
56      printf("%p - %p - %p\n", &d1.year, &d1.month, &d1.day);
57
58      int s = sizeof(d1);
59      printf("%d\n", s);
60
61      */
62 }

  1 #include <stdio.h>
  2 // 从这行开始，一直到文件结尾，都是有效（跟全局变量一样）
  3 struct Date
  4 {
  5     int year;
  6     int month;
  7     int day;
  8 };
  9
 10 int a;
 11
 12 void test2()
 13 {
 14     struct Date
 15     {
 16         int year;
 17     };
 18     // 这里使用的是test2函数内部的struct Date类型
 19     struct Date d1 = {2011};
 20
 21
 22     // 结构体类型也是有作用域，从定义类型的那一行开始，一直到代码块结束
 23     struct Person
 24     {
 25         int age;
 26     };
 27
 28     struct Person p;
 29
 30     a  = 10;
 31 }
 32
 33 int main()
 34 {
 35     struct Date d1 = {2009, 8, 9};
 36
 37
 38     test2();
 39
 40     // 不能使用test2函数中定义的类型
 41     // struct Person p2;
 42
 43     return 0;
 44 }
 45
 46 // 定义结构体变量
 47 void test()
 48 {
 49     // 定义结构体变量的第3种方式
 50     struct {
 51         int age;
 52         char *name;
 53     } stu;
 54
 55     struct {
 56         int age;
 57         char *name;
 58     } stu2;
 59
 60
 61     /*结构体类型不能重复定义
 62      struct Student
 63      {
 64      int age;
 65      };
 66
 67      struct Student
 68      {
 69      double height;
 70      };
 71
 72      struct Student stu;
 73      */
 74
 75     /* 错误写法：结构体类型重复定义
 76      struct Student
 77      {
 78      int age;
 79      double height;
 80      char *name;
 81      } stu;
 82
 83      struct Student
 84      {
 85      int age;
 86      double height;
 87      char *name;
 88      } stu2;c
 89      */
 90
 91     /*
 92      这句代码做了两件事情
 93      1.定义结构体类型
 94      2.利用新定义好的类型来定义结构体变量
 95      */
 96     // 定义变量的第2种方式：定义类型的同时定义变量
 97     /*
 98      struct Student
 99      {
100      int age;
101      double height;
102      char *name;
103      } stu;
104
105      struct Student stu2;
106      */
107
108     /*
109      // 定义变量的第1种方式：
110      // 1.类型
111      struct Student
112      {
113      int age;
114      double height;
115      char *name;
116      };
117
118      // 2.变量
119      struct Student stu = {20, 1.78, "jack"};
120      */
121 }

 1 int main()
 2 {
 3     struct RankRecord
 4     {
 5         int no; // 序号  4
 6         int score; // 积分 4
 7         char *name; // 名称 8
 8     };
 9     /*
10     struct RankRecord r1 = {1, "jack", 5000};
11     struct RankRecord r2 = {2, "jim", 500};
12     struct RankRecord r3 = {3, "jake",300};
13     */
14
15     //int ages[3] = {10, 19, 29};
16
17     //int ages[3];
18     // 对齐算法
19     // 能存放3个结构体变量，每个结构体变量占16个字节
20     // 72
21     /*
22      int no; // 序号  4
23      char *name; // 名称 8
24      int score; // 积分 4
25      */
26     // 48
27     /*
28      int no; // 序号  4
29      int score; // 积分 4
30      char *name; // 名称 8
31      */
32     struct RankRecord records[3] =
33     {
34         {1, "jack", 5000},
35
36         {2, "jim", 500},
37
38         {3, "jake",300}
39     };
40
41     records[0].no = 4;
42     // 错误写法
43     //records[0] = {4, "rose", 9000};
44
45     for (int i = 0; i<3; i++)
46     {
47         printf("%d\t%s\t%d\n", records[i].no, records[i].name, records[i].score);
48     }
49
50     //printf("%d\n", sizeof(records));
51
52
53     return 0;
54 }