黑马程序员-----结构体数组

------<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 = &num;

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 }
时间： 2024-10-19 14:22:18

黑马程序员-----结构体数组的相关文章

黑马程序员----结构体

结构体(构造类型) 结构体和数组的区别: 数组:只能由多个相同类型的数据构成: 结构体:可以有多个不同类型的数据构成: 一.结构体的定义:(2步) 1.定义结构体类型 struct Person { // 里面的3各变量,可以称为结构体的成员或者属性 int age; double height; char *name; }; 2.根据结构体类型,定义结构体变量 struct Person p = {20, 1.55, "jack"}; p.age = 30; p.name = &qu

黑马程序员----结构体（Range、Point、Size、Rect）的使用

1.NSRange:(范围) 2.NSPoint\CGPoint(NSPoint相当于CGPoint):(位置:X.Y) 设置Point的两种方式: 1.NSPoint point = NSMakePoint(100,56); 2.NSPoint point2 = CGPointMake(40,63); 将NSPoint类型转换成字符串类型: 3.NSSize\CGSize(NSSize相当于CGSize):(尺寸:长.宽) 设置而Size的两种方式: 1.NSSize size = NSMak

黑马程序员——Java基础-数组

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 概念 数组就是同一种类型那个数据的集合,是一个容器,是引用类型,存储在堆中. 好处:可以自动给数组中的元素从0开始编号,方便操作这些元素 格式: 1. int[] arr=new int[5]; 创建一个长度为5 的,变量名为arr,类型为整型的数组. 2. int[] arr=new []{5,6,8,3,4} int[] arr={5,6,8,3,4} 数组中常见问题: 1.数组角标越界

黑马程序员-java基础-数组的反射

数组是一个对象,具有相同维数和元素类型的数组具有相同的字节码(相同类型). 所有数组其父类都是object.Object o = new int[2] 或者 Object o = new int[2][2];不会报错 基本类型的一维数组可以被当作Object类型使用,不能当作Object[]类型使用: int[] arr = new int[2]; Object o1 = arr Object[] o2 = arr //会报错 Object[] o3 = new Object[2][2];可以,

黑马程序员——C语言——数组

一.一维数组 存放一组同种类型的数据. 1.数组的定义 元素类型 数组名[元素个数]; 1 //都是正确写法 2 int ages[5] = {10 , 11, 12, 67, 56}; 3 int ages[5] = {10, 11}; 4 int ages[5] = {[3] = 10, [4] = 11}; 5 int ages[] = {10, 11, 14}; 6 7 // 错误写法 8 int ages[]; 2. 数组的初始化 1 // 错误写法 2 //只能在定义数组的同时进行初

黑马程序员-java基础-数组&amp;进制转换

第一讲  数组初始化&操作 1.  数组定义 概念:数组是同一种类型数据的集合,其实数组就是一个容器.数组中的元素从0开始编号,这样方便了对这些元素进行操作(获取.修改改.排序等). 数组的定义格式有: Int[] arr = new int[10]; ——这里指定数组的长度,后续需要分别对每一个元素赋值: Int[] arr = new int[]{2,1,5,9}:——创建数组实体并初始化,不需要指定长度: Int[] arr = {2,1,5,9};——定义数组并初始化: 2.  数组操作

黑马程序员-JAVA学习日记-数组YNPB

黑马程序员学习笔记黑马程序员编程基础数组培训.培训.期待与您交流!数组:是存储同一种数据类型的的集合,也叫容器:特点:是数组中每个元素都有索引从开始:数组的定义式:数据类型数组名数据类型元素个数:数据类型数组名数据类型元素个数:如:数据类型数组名数据类型元素数据类型数组名元素如:如果元素确定就用这一种:数组中有一个属性:获取数组中的元素个数,即数组的长度:中的内存机制:栈:存储局部变量,一般定义在函数内的变量成为局部变量:特点:当内存中数据操作完成后,所占空间会自动释放栈内存堆:是通过创建的实体

黑马程序员---C基础12【结构体数组】【结构体指针】【结构体嵌套】【作为函数参数】【枚举类型】

------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

【黑马程序员】————结构体

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 一.什么是结构体 数组:只能由多个相同类型的数据构成 结构体:可以由多个不同类型的数据构成 二.结构体的定义 1.定义形式 结构体内部的元素,也就是组成成分,我们一般称为"成员". 结构体的一般定义形式为: 1 struct 结构体名{ //struct是关键字,是结构体类型的标志 2 3 类型名1 成员名1; 4 5 类型名2 成员名2; 6 7 …… 8 9 类型名n 成员名n;