黑马程序员——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] = (struct Student){"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 = (struct Car){4,180};

    

    struct Car *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(struct Car c){

    c.wheels= 2;

}

/**

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

 *

 *  @param p 结构体指针

 */

void fixCar3(struct Car *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;

}