------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -----
第一讲 结构体数组
一、结构体数组的概念
数组的元素也可以是结构类型的。因此可以构成结构型数组。结构数组的每一个元素都是具有相同结构类型的下表结构变量。在实际应用中，经常用结构数组来表示具有相同数据结构的一个群体。如一个班的学生档案，一个车间职工的工资表等。
二、结构数组定义
定义格式：
struct 结构名{
成员表列
}数组名[数组长度];
例如：定义一个长度为5的数组，其中每一个元素都是stu结构类型。
struct stu{
int num;
char *name;
char sex;
float score;
}boy[5];
定义了一个结构数组boy，共有5个元素，boy[0]~boy[4].每个数组元素都具有struct stu的结构形式。
1 /*
2 结构体数组：
3
4 用来存放大量的结构体相同的结构体变量。
5
6 结构体数组定义：
7
8 结构体数组定义的第一种方式：
9 1.定义结构体的同时，定义数组
10 struct Student{
11 int age;
12 char *name;
13 int sno;
14 float score;
15
16 }stu[5];
17
18 2.先定义结构体，后定义数组
19 struct Student boy[5];
20
21 */
22
23 // 二、结构数组的初始化和遍历
24
25 #include <stdio.h>
26 #include <string.h>
27 int main(int argc,const char * argv[]) {
28
29 //一、结构体数组的初始化方法
30
31 //1.定义结构体数组的时候，进行初始化
32 struct Student{
33
34 char name[20];
35 int age;
36 }boy[3]={{"sb",18},{"zbz",38},{"cgx",28}};
37
38 //2.定义的同时进行初始化
39 struct Student girls[2]={{"fengjie",18},{"cjk",28}};
40
41
42 //3.先定义后初始化,整体赋值
43 struct Student ds[2];
44 // ds[0]=(struct Student){"xzmly",18};
45 // ds[1]=(struct Student){"bdjy",18};
46
47 //4.先定义结构体数组，后初始化
48 struct Student stu[2];
49 //stu[0].name = "zhangsan"; 不能
50 strcpy(stu[0].name,"zhangsan"); //第一种方法
51 scanf("%s",stu[0].name ); //第二种方法
52
53 stu[0].age = 19;
54
55 //二、结构数组的遍历*******
56
57 for (int i =0;i<3;i++){
58
59 printf("name:%s,age:%d\n",boy[i].name,boy[i].age);
60 }
61
62 return 0;
63 }
1 /*
2 思考&实现1:
3 struct stu{
4 int num;
5 char *name;
6 char sex;
7 float score;
8 };
9 struct stu boy[5]={
10 {101,"Li ping",'F',45},
11 {102,"Zhang ping",'M',62.5},
12 {103,"He fang",'F',92.5},
13 {104,"Cheng ling",'M',87},
14 {105,"Wang ming",'M',58}
15
16 };
17 1) 利用上面stu的结构体，计算学生平均成绩和不及格的人数
18
19 2）打印80-100分学生的成绩及姓名
20 */
21
22 #include <stdio.h>
23
24 int main(int argc,const char * argv[]) {
25
26 struct stu{
27 int num;
28 char *name;
29 char sex;
30 float score;
31 };
32
33 //1.定义结构体数组
34 struct stu boy[5]={
35 {101,"Li ping",'F',45},
36 {102,"Zhang ping",'M',62.5},
37 {103,"He fang",'F',92.5},
38 {104,"Cheng ling",'M',87},
39 {105,"Wang ming",'M',58}
40
41 };
42
43 //2.有一个循环
44 //
45 float sum = 0.0f;
46 int count = 0; //保存不及格的人数
47 for (int i = 0;i<5;i++) {
48
49 // 去计算总成绩
50 sum+=boy[i].score;
51 //判断成绩是否小于60 ，如果小于60 ，要让计算器+1
52 if(boy[i].score<60){
53 count++;
54 }else if(boy[i].score>=80 && boy[i].score<=100){
55 //判断是否大于80小于100
56
57 //如果在这个区间，应该输出姓名和成绩
58 printf ("姓名:%s,成绩:%.2f\n",boy[i].name,boy[i].score);
59 }
60 }
61
62 printf("平均值:%.2f\n",sum/5);
63 printf("不及格人数:%d\n",count);
64
65 return 0;
66 }
67
68 /*
69 运行结果:
70
71 姓名:He fang,成绩:92.50
72 姓名:Cheng ling,成绩:87.00
73 平均值:69.00
74 不及格人数:2
75 Press any key to continue
76
77 */
1 三、实现简易通讯录
2 思考&实现1：
3 1）用结构体数组实现通讯录
4
5 #include <stdio.h>
6 #define LEN 5
7
8 struct Person{
9 //定义数组保存联系人姓名
10 char name[21];
11 //保存电话号码
12 char telNum[12];
13
14 }contacts[LEN];
15
16 int main(int argc,const char * argv[]) {
17
18 //1.先定义结构体
19
20 //2.定义结构体数组
21 struct Person contacts[LEN];
22
23 //3.让用户输入要保存的联系人信息
24 printf("请输入要保存的联系人，格式:姓名，电话\n");
25
26 for (int i=0;i<LEN;i++){
27
28 scanf("%s %s",contacts[i].name,contacts[i].telNum);
29 }
30 //4.保存以后，立即查看一下
31 for (int j=0;j<LEN;j++){
32
33 printf("姓名:%s,电话:%s\n",contacts[j].name,contacts[j].telNum);
34 }
35
36 return 0;
37 }
第二讲 结构指针定义和初始化
一、指向结构体变量的指针
推导：
int num = 10;
int *p = #
p-->num
struct Person s1;
struct Peron *p2 = &s1;
一个指针变量当用来指向一个结构变量时，称之为结构指针变量。结构指针变量中的值是所指向的结构变量的首地址。通过结构指针即可访问该结构变量，这与数组指针和函数指针的情况是相同的。
结构指针变量说明的一般形式为：
struct 结构名 *结构指针变量名
/*
1.什么是结构体指针?
用来存放结构体变量地址的指针变量
2.结构体指针定义
struct 结构体名 *指针变量名;
//定义一个结构体
struct Car{
int lunzi;
int speed;
}car1;
struct Car *p=NULL; //定义一个结构体指针变量
p = &car1;
p = &Car; //错误的 它是一个结构体
//结构体名 Car
//结构体变量名 car1
//结构体指针 p
*/
第三讲 结构体指针间接访问成员值
一、指向结构体变量的指针
其访问的一般形式为：
(*结构体指针变量).成员名
或为:
结构体指针变量->成员名
例如：
(*pstu).num
或者：
pstu->num
1 /*
2 1.结构体变量的成员值
3
4 struct Student{
5
6 int age ;
7 char *name ;
8 };
9
10 //定义一个结构体的变量
11
12 struct Student stu1={18,"张三丰"};
13
14 //结构体变量的成员值有2个
15 //stu1.age 值 18
16 //stu1.name 值 张三丰
17
18 2.用结构体指针间接的访问结构体变量的成员值
19
20 struct Student *p = &stu1;
21
22 //使用p 获取 18 张三丰
23
24 两种方法:
25
26 1. (*p).age 访问年龄 (*p)--->stu1
27 (*p).name 访问姓名
28
29 2. p->age
30 p->name
31
32 注意: p一定是一个结构体指针
33 */
34
35 #include <stdio.h>
36
37 int main(int argc,const char *argv[]){
38
39 // 1.结构体变量的成员值
40
41 struct Student{
42
43 int age ;
44 char *name ;
45 };
46
47 //定义一个结构体的变量
48
49 struct Student stu1={18,"张三丰"};
50
51 //结构体变量的成员值有2个
52 //stu1.age 值 18
53 //stu1.name 值 张三丰
54
55 // 2.用结构体指针间接的访问结构体变量的成员值
56
57 struct Student *p = &stu1;
58 printf("姓名: %s,年龄: %d\n",(*p).name,(*p).age);
59 printf("姓名: %s,年龄: %d\n",p->name,p->age);
60
61 return 0;
62 }
第四讲 结构体嵌套使用
一、 结构体嵌套使用
（我们学过的有if嵌套
if(){
if(){
}
}
三目运算符
(?:)?:
for运算符
for(){
for(){
}
}
递归函数
max(max(),45);
）
1、成员也可以又是一个结构，即构成了嵌套的结构。
//结构体嵌套：结构体定义的里面有其他结构体。
//结构体不可以嵌套自己变量，可以嵌套指向自己这种类型的指针。
例如；
struct Date{
int month;
int day;
int year;
};
struct stu{
int num;
char *name;
char sex;
struct Date birhday;
float score;
};
1 /*
2 结构体嵌套：
3
4 结构体定义中，结构体的成员又是另外一个结构体变量
5
6 结构体的嵌套的注意事项：
7
8 1.结构体定义中可以嵌套其他结构体类型的变量
9 不可以嵌套自己这个类型的变量
10
11 struct Date{
12 int year;
13 int month;
14 int day;
15
16 };
17 //定义了一个学生的结构体
18 struct Student {
19 char *name;
20 int age;
21 float score;
22 // strcut Student stu; //错误的 不能嵌套自己类型的变量
23 // struct Student *stu; //正确的 嵌套了一个当前类型的结构体指针
24 struct Date birthday;
25 };
26
27 2.可以嵌套自己类型的指针
28 */
29
30 #include <stdio.h>
31
32 int main(int argc,const char *argv[]){
33
34 // 结构体嵌套：
35
36 //结构体定义中，结构体的成员又是另外一个结构体变量
37
38 // 结构体的嵌套的注意事项：
39
40 //1.结构体定义中可以嵌套其他结构体类型的变量
41 //不可以嵌套自己这个类型的变量
42
43 struct Time{
44 int hour;
45 int min;
46 int sec;
47 };
48 //定义了一个Date的结构体
49 struct Date{
50 int year;
51 int month;
52 int day;
53 //嵌套Time的结构体
54 struct Time time;
55
56 };
57 //定义了一个学生的结构体
58 struct Student {
59 char *name;
60 int age;
61 float score;
62 // strcut Student stu; //错误的 不能嵌套自己类型的变量
63 // struct Student *stu; //正确的 嵌套了一个当前类型的结构体指针
64 struct Date birthday;
65 };
66
67 // 2.可以嵌套自己类型的指针
68 // struct Student *stu; //正确的 嵌套了一个当前类型的结构体指针
69
70 // 嵌套的结构体如何进行初始化
71 struct Student stu1={"张三丰",28,59.99f,{1200,12,12,{12,12,12}}}; //定义了一个结构体变量
72
73 // 嵌套的结构体如何进行访问
74 printf("姓名: %s,年龄: %d(生日: %d-%02d-%02d ),成绩: %.2f\n",stu1.name,stu1.age,stu1.birthday.year,stu1.birthday.month,stu1.birthday.day,stu1.score);
75 //访问时间
76 printf("姓名: %s,年龄: %d(生日: %d-%02d-%02d %02d:%02d:%02d),成绩: %.2f\n",stu1.name,stu1.age,stu1.birthday.year,stu1.birthday.month,stu1.birthday.day,stu1.birthday.time.hour,stu1.birthday.time.min,stu1.birthday.time.sec,stu1.score);
77
78 // 3.结构体嵌套自身的指针
79
80 struct Person{
81
82 char *name;
83 int age;
84 //嵌套自己类型的指针
85 struct Person *child;
86
87 };
88 //结构体嵌套自身指针的，初始化
89 //定义kim
90 struct Person kim = {"kim",8,NULL};
91 //struct Person *child = &kim;
92 struct Person p1 = {"林志颖",38,&kim};
93
94 //结构体嵌套自身指针的，访问
95 printf("%s的儿子是:%s,儿子的年龄: %d\n",p1.name,(*p1.child).name,(*p1.child).age );
96 printf("%s 的儿子是: %s,儿子的年龄: %d\n",p1.name,p1.child->name,p1.child->age );
97 return 0;
98 }
第五讲 结构体变量及成员作为函数参数
1、成员值做函数的参数
结构体成员属性作为函数的参数就是值传递（成员变量是数组除外）。
2、结构体变量名作为函数的参数
在ANSI C标准中允许用结构变量做函数参数进行整体传送。但是这种传送要将全部成员逐个传送，特别是成员为数组时将会使传送的时间和空间开销很大，严重地降低了程序的效率。因此最后的办法就是使用指针，即用指针变量做函数参数进行传送。这时由实参传向形参的只是地址，从而减少了时间和空间的开销。
1 #include <stdio.h>
2
3 struct Car{
4
5 int lunzi;
6 int speed;
7
8 };
9
10 void xiuche(int n){
11
12 n =2;
13 }
14
15 //用结构体变量作为函数的参数
16 void xiuche1(struct Car c1){
17
18 c1.lunzi = 2; //这个轮子数这两种方法都改不了
19
20 }
21 int main(int argc, const char *argv[]){
22
23 //定义一个结构体变量
24 struct Car car1={4,200};
25 //car1.lunzi 结构体变量成员值
26 //1.用结构体变量的成员值作为函数的参数，实质是值传递
27 xiuche(car1.lunzi);
28 printf("%d\n",car1.lunzi); //4
29 //2.用结构体变量作为函数的参数,实质上还是值传递
30 xiuche1(car1);
31 printf("%d\n",car1.lunzi); //4
32
33 return 0;
34 }
第六讲 结构指针作为函数的参数
1 #include <stdio.h>
2
3 struct Car{
5 int lunzi;
6 int speed;
8 };
9 //结构体指针作为函数的参数
10 // c1 是一个结构体指针
11 void xiuche2(struct Car *c1){
13 c1->lunzi = 2;
15 }
16 int main(int argc, const char *argv[]){
17
18 //定义一个结构体变量
19 struct Car car1={4,200};
20
21 //注意:用结构体变量的地址传递给函数
22 // 也可以理解为用结构体指针作为函数的参数
23
24 //实质 : 是地址传递
25 xiuche2(&car1);
26 printf("%d\n",car1.lunzi); //2
27
28 return 0;
29 }
来源：https://www.cnblogs.com/xiaokang520/p/5062334.html