黑马程序员——c语言基础：结构体（高级）

1.结构体数组

 结构体数组：

   数组的元素也可以是结构类型的。因此可以构成结构型数组。结构数组的每一个元素都是具有相同结构类型的结构变量。

 结构体数组定义：

    1)定义结构体的同时，定义数组

    struct Student{

        int age;

        char *name;

        int s_no;

        float score;

    } stu[5];

    2）先定义结构体，再定义数组

    struct Student boy[5];

 

 结构体数组的初始化

    1）定义的同时初始化

    2）先定义后初始化

结构体数组的初始化和遍历举例：

#include <stdio.h>

int main(int argc,const char * argv[]) {

    // 1.定义结构体数组的时候，进行初始化

   struct Student{

       char name[20];

       int age;

    } boys[3] ={{"zhangsan",12},{"lisi",23},{"wangwu",34},};

    

    // 2.定义的同时进行初始化

   struct Student girls[2] = {{"lucy",21},{"lily",32}};

    

    // 3.先定义后初始化,整体赋值

   struct Student ds[2];

    ds[0] = (structStudent){"wangwei",19};

    

    // 4.先定义后初始化，部分赋值

   struct Student stu[2];

    stu[0].age =23;

    

    //结构体数组的遍历

   for (int i =0; i < 3; i ++) {

       printf("name : %s, age :%d\n",boys[i].name, boys[i].age);

    }

    

   return 0;

}

应用1：利用定义好的结构体数组，1、计算学生平均成绩和不及格人数。2、打印80-100分学生的成绩和姓名

#include <stdio.h>

int main(int argc,const char * argv[]) {

    // 定义结构体

   struct stu{

       int num;

       char *name;

       char sex;

       float score;

    };

    

    // 定义结构体数组

   struct stu boy[5] ={

        {101,"Li ping",'F',45},

        {102,"Zhang ping",'M',62.5},

        {103,"He fang",'F',92.5},

        {104,"Cheng ling",'M',87},

        {105,"Wang ming",'M',58},

    };

    

    // 定义变量

   float sumScore = 0;// 总成绩

   float avgScore = 0;// 平均成绩

   int bjg = 0;// 不及格人数

    

   for (int i =0; i < 5 ; i ++) {

        sumScore += boy[i].score;// 总分累加

       if (boy[i].score <60) { // 如果分数低于60

            bjg ++;// 不及格人数+1

        }

       if (boy[i].score >=80 && boy[i].score <=100) { // 如果分数在80-100之间

           printf("score = %.2f name = %s\n",boy[i].score, boy[i].name);// 打印成绩和姓名

        }

    }

    

    // 计算平均分

    avgScore = sumScore /5;

    

    //打印学生平均成绩和不及格人数

    printf("学生的平均成绩为%.2f不及格学生人数为%d\n",avgScore, bjg);

   return 0;

}

应用2：用结构体实现通讯录，让用户从键盘输入要保存的姓名和电话，然后打印出来。

#include <stdio.h>

#define LEN 3

int main(int argc,const char * argv[]) {

    

    // 定义一个结构体

   struct list{

       char name[21];

       char number[12];

    };

    

    //定义一个结构体数组

   struct list l[LEN];

    

    // 提示用户输入

    printf("请输入联系人，格式：姓名电话号码\n");

    

    //接收并保存用户输入数据

   for (int i =0; i < LEN; i ++) {

       scanf("%s %s", l[i].name, l[i].number);

    }

    

    // 输出通讯录

   for (int i =0; i < LEN; i ++) {

       printf("姓名：%s电话：%s\n", l[i].name, l[i].number);

    }

   return 0;

}

2.结构体指针

 结构体指针:用来存放结构体变量地址的指针变量。

 结构体指针的定义

    struct结构体名 *指针变量名;

 结构体指针间接访问成员值

   其一般形式为： （*结构体指针变量）.成员名 或为： 结构体指针变量 ->成员名

应用举例：

#include <stdio.h>

int main(int argc,const char * argv[]) {

    

    //先定义一个结构体变量

    struct Car{// Car 是结构体名

       int wheels;

       int speed;

    } car1; // car1是结构体变量名

    

    // 初始化car1

    car1 = (structCar){4,180};

    

    structCar *p = NULL; // 定义一个结构体指针变量p并初始化为NULL

    

    p = &car1; // 结构体指针变量p指向了结构体变量car1

    

    //用结构体指针间接访问结构体变量的成员值

    printf("car1的轮子数为%d，速度为%d",(*p).wheels, p ->speed);

    

   return 0;

}

3.结构体嵌套

 结构体的嵌套：

   结构体定义中，结构体的成员又是另外一个结构体变量

 结构体嵌套的注意事项：

    1）结构体定义中可以嵌套其他结构体类型的变量，不可以嵌套自己这个类型的变量。

    2）可以嵌套自己类型的指针。

应用举例：

#include <stdio.h>

int main(int argc,const char * argv[]) {

    // 定义了一个Date的结构体

   struct Date{

       int year;

       int month;

       int day;

    };

    

    // 定义了一个Student结构体

   struct Student{

       char *name;

       int age;

       float score;

        // struct Student stu; // 错误的，嵌套了自己这个类型的变量

        // struct Student *stu; // 嵌套了当前类型的指针，是可以的

       struct Date birthday;// 嵌套了其他结构体类型的变量

    };

    

    //对嵌套的结构体进行初始化

   struct Student gam = {"gamhunter",25, 99.99, {1989,11,11}};

    

    //对嵌套的结构体进行访问

    printf("姓名：%s，年龄：%d，成绩：%.2f，生日：%d-%02d-%02d\n", gam.name, gam.age, gam.score, gam.birthday.year, gam.birthday.month, gam.birthday.day);

    

    

    //结构体嵌套自身的指针

   struct Person {

       char *name;

       int age;

       struct Person *child;// 嵌套自己类型的指针

    };

    

    //初始化嵌套自身指针的结构体

   struct Person child = {"kimy",4, NULL}; // 定义并初始化kimy

   struct Person father = {"林志颖",40, &child}; // 定义并初始化林志颖

    //访问嵌套自身指针的结构体

   printf("%s的儿子是%s，儿子的年龄是：%d\n", father.name, (*father.child).name, father.child ->age);

    

   return 0;

}

4.结构体变量、成员及指针作为函数参数

注意：

用结构体变量及成员作为函数参数，实质上都是值传递

用结构体指针作为函数参数，实质上是地址传递

#include <stdio.h>

// 定义了一个结构体Car

struct Car {

   int wheels;

   int speed;

};

/**

 *  结构体变量的成员作为函数参数

 *

 *  @param n 轮子数

 */

void fixCar1(int n){

    n =2;

}

/**

 *  结构体变量作为函数参数

 *

 *  @param n 轮子数

 */

void fixCar2(structCar c){

    c.wheels=2;

}

/**

 *  结构体指针作为函数参数

 *

 *  @param p 结构体指针

 */

void fixCar3(structCar *p){

    p ->wheels = 2;

}

int main(int argc,const char * argv[]) {

    //定义了一个结构体变量并初始化

   struct Car car1 = {4,200};

    

    //1.结构体变量的成员作为函数参数

   fixCar1(car1.wheels);

    

    //查看结构体变量成员有无变化

    printf("%d\n", car1.wheels);// 输出值还是4，结论：用结构体变量的成员值作为函数的参数，实质是值传递

    

    // 2.用结构体变量作为函数的参数

   fixCar2(car1);

    printf("%d\n", car1.wheels);// 输出值还是4，结论：用结构体变量的作为函数的参数，实质也是值传递

    

    // 3.用结构体指针作为函数参数

   struct Car *c = &car1;

   fixCar3(c);

    printf("%d\n", car1.wheels);// 输出值是2，结论：用结构体指针作为函数参数，实质是地址传递

    

   return 0;

}