------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
【结构体数组】
1、结构体数组：
结构体数组的每一个元素都是具有相同结构类型的下标结构变量；（可以表示一个群体，一个班学生档案）
2、结构数组定义：
定义格式：
struct 结构名{
成员列表；
}数组名[数组长度]；
1 1）定义结构体的同时定义数组；
2
3 struct stu{
4
5 int num;
6
7 char name[10];
8
9 int age;
10
11 }arr[10];
12
13 2）先定义结构体后定义数组
14
15 struct stu{
16
17 int num;
18
19 char name[10];
20
21 int age;
22
23 }
24
25 struct stu arr[10];
26
27 3、结构体数组的初始化：
28
29 1）定义结构体数组的时候，进行初始化；
30
31 struct stu{
32
33 int num;
34
35 char name[10];
36
37 int age;
38
39 }arr[1]={10,"sdfs",10};
40
41 2）定义的同时进行初始化；
42
43 struct stu{
44
45 int num;
46
47 char name[10];
48
49 int age；
50
51 };
52
53 struct stu arr[1]={10,"sdfs",10};
54
55 3）先定义后初始化；
56
57 arr[0]=(struct stu){10,"sdfs",10};
58
59 4)先定义结构体数组再初始化；
60
61 arr[0].age=10;
62
63 arr[0].num=10;
64
65 strcpy(arr[0].name, "张三");
4、结构数组的遍历：
printf("%d %s %d\n",arr[0].age,arr[0].name,arr[0].num);
【结构体指针】
1、指向结构体变量的指针：
结构指针变量中的值是所指向的结构变量的首地址；
一般格式：
struct 结构名 *结构指针变量名；可以看成一个类型，如int
2、定义：
1 1）
2
3 struct car{
4
5 int num;
6
7 int speed;
8
9 }car1,*p;
10
11 2）
12
13 struct car{
14
15 int num;
16
17 int speed;
18
19 }car1;
20
21 struct car *p;
22
23 3）
24
25 struct car{
26
27 int num;
28
29 int speed;
30
31 }car1;
32
33 struct car *p=&car1;
结构体名：car；
结构体变量名：car1
结构体指针：p；
3、指向结构体变量的指针
（*结构指针变量）.成员名；
结构指针变量--->成员名；
1 1) struct car{
2
3 int num;
4
5 int speed;
6
7 }car1;
8
9 struct car *p = &car1;
10
11 (*p).num=10;
12
13 printf("%d\n",(*p).num);
14
15 return 0;
16
17 2)
18
19 struct car{
20
21 int num;
22
23 int speed;
24
25 }car1;
26
27 struct car *p = &car1;
28
29 (*p).num=10;
30
31 p->speed=10;
32
33 printf("%d %d\n",(*p).num,p->speed);
此处p一定是一个结构体指针！才可用—>;
【结构体嵌套】
1、结构体嵌套使用；（if嵌套，三目运算符嵌套，for循环嵌套，递归函数）
成员也可以又是一个结构，即构成了嵌套的结构；
1）结构体定义的里面有其他结构体；不可以嵌套自己类型的变量；
2）结构体不可以嵌套自己的变量，但是可以嵌套指向自己类型的指针；
1 struct date{
2 int year;
3 int mon;
4 int day;
5 };
6 struct stu{
7 char *name;
8 int num;
9 struct stu *s;可以用指向自己的指针；
10 struct date da;可以看成一个特殊的类型，用法类似int，char的类型；
11
12 };
2、结构体嵌套使用
1 1) struct stu stu1={"张三",10,{1992,7,9}};
2 printf("name: %s\nage: %d\ndate: %d-%02d-%02d\n",stu1.name,stu1.num,stu1.da.year,stu1.da.mon,stu1.da.day);
3
4 struct stu stu1={"张三",10,{1992,7,9,{2,3,4}}};
5 printf("name: %s\nage: %d\ndate: %d-%02d-%02d %02d:%02d;%02d\n",stu1.name,stu1.num,stu1.da.year,stu1.da.mon,stu1.da.day,stu1.da.ti.hour,stu1.da.ti.min,stu1.da.ti.sec);
2） struct person{
char *name;
int age;
struct person *child;
};
struct person kim={"kim",8,NULL};
struct person p1={"lizhiying",40,&kim};
printf("%s的儿子是:%s,儿子的年龄:%d\n",p1.name,(*p1.child).name,(*p1.child).age);
用指针来嵌套；
3、成员值做函数的参数；
结构体成员作为函数的参数就是值传递；
1 struct car{
2
3 int lunzi;
4
5 int speed;
6
7 };
8
9 void xiu(int n){
10
11 n = 2;
12
13 };
14
15 void xiu1(struct car c1){
16
17 c1.lunzi=2;
18
19 };
20
21 int main(int argc, const char * argv[]) {
22
23 // insert code here...
24
25 struct car car1={4,200};
26
27 xiu(car1.lunzi);
28
29 xiu1(car1);
30
31 printf("%d\n",car1.lunzi);
32
33 return 0;
34
35 }
4、结构体指针作为函数参数；
实质是地址传递；
用结构体变量的地址传递给函数；
也可以理解为用结构体指针作为函数的参数
1 struct car{
2
3 int lunzi;
4
5 int speed;
6
7 };
8
9 void xiu(struct car *p)存的是一个地址{
10
11 p->lunzi=2;
12
13 }
14
15 int main(int argc, const char * argv[]) {
16
17 // insert code here...
18
19 struct car car1={4,200};
20
21 xiu(&car1);将地址传递；
22
23 printf("%d\n",car1.lunzi);
24
25 return 0;
26
27 }
【枚举类型】
1、枚举类型：
有些变量的取值被限定在一个有限的范围内，例如：一个星期七天；
枚举是一种基本数据类型，而不是一中构造类型，因为他不能再分解为任何基本类型；
2、定义
一般形式：
enum 枚举类型名{枚举值表}；
在枚举值表中应罗列出所有的可用值，这些值也称为枚举元素；
枚举元素的命名：k Icolor White
enum iColor{kIcolorWhite,kIcolorBlack,kIcolorTHJ};
enum iColor c;
3、枚举变量的定义：
enum iColor c;可以当成一种类型，用法同int，char·····；
enum iColor{kIcolorWhite,kIcolorBlack,kIcolorTHJ}a,b;
4、枚举类型变量的初始化；
enum iColor{kIcolorWhite,kIcolorBlack,kIcolorTHJ}a,b;
enum iColor c;
c = kIcolorWhite;
5、枚举变量的使用；
1）枚举类型定义完成后，系统会默认自动给每一个元素赋值一个int的初始值，从第一个元素开始值0，依次加1
// 0 1 2 int都是整型的
enum iColor{kIcolorWhite,kIcolorBlack,kIcolorTHJ};
2）手动赋值，
// 0 1 2 int都是整型的
// 0 3 4
enum iColor{kIcolorWhite,kIcolorBlack=3,kIcolorTHJ};
5、应用；
可以定义尝试性一类数据，一周的星期数；
枚举元素可以理解为整型的变量，int；