C语言零基础入门教程：176-181节

176. 初识结构体 (struct)

在C语言中，结构体（struct）是一种用于将不同类型的数据组合在一起的用户定义的数据类型。结构体允许你把多个不同类型的元素（成员）聚集在一起，形成一个复杂的数据结构。

1. 结构体的定义

结构体的基本语法如下：

struct 结构体名称 {
    成员类型 成员名称1;
    成员类型 成员名称2;
    // ...
};

其中，结构体名称是你定义的结构体类型名，成员类型是成员的数据类型，而成员名称是你为每个成员指定的名字。

2. 例子：日期结构体

我们可以用结构体来表示日期，包含日期、月份和年份三个成员。下面是一个定义日期的结构体示例：

struct Date {
    int day;
    int month;
    int year;
};

此结构体包含三个int类型的成员：day（日）、month（月）和year（年）。

3. 例子：人物结构体

类似地，我们也可以使用结构体来表示人物信息，包含名字、年龄和身高等属性。以下是一个表示人物的结构体定义：

struct Person {
    char name[50];   // 姓名，字符串类型
    int age;         // 年龄，整数类型
    float height;    // 身高，浮点类型
};

此结构体包含三个成员：

• name（字符串，用char数组表示）
• age（年龄，int类型）
• height（身高，float类型）

4. 结构体变量的定义与初始化

定义了结构体类型后，我们可以通过该类型来声明结构体变量，并为其成员赋值。

• 定义和初始化结构体变量：

struct Date today = { 12, 2, 2024 };  // 初始化日期为2024年2月12日

这里，我们创建了一个Date类型的变量today，并直接初始化它的day、month、year成员为12、2、2024。

• 定义和初始化人物结构体变量：

struct Person nix = { "Nix", 20, 175 };  // 初始化Nix的姓名、年龄和身高
struct Person zhangsan = { "张三", 32, 170 };  // 初始化张三的姓名、年龄和身高

这里，我们创建了两个Person类型的结构体变量：nix和zhangsan，分别初始化了姓名、年龄和身高。

5. 结构体成员访问

要访问结构体中的成员，可以通过.运算符来访问。例如：

printf("今天是 %d/%d/%d\n", today.day, today.month, today.year);
printf("Nix的年龄是 %d，身高是 %.2f cm\n", nix.age, nix.height);

在这个例子中，today.day、today.month、today.year用于访问today结构体的不同成员，nix.age、nix.height用于访问nix结构体的成员。

6. 结构体总结

• 结构体（struct） 是一种自定义的数据类型，可以将不同类型的数据组合在一起。
• 结构体定义 通过struct关键字进行。
• 可以通过.运算符来访问结构体的成员。
• 结构体成员 可以是不同类型的数据，比如int、char、float等。

结构体是C语言中一个非常重要的工具，广泛应用于复杂数据的处理和管理。

---

177. 创建结构体变量与访问方式

在C语言中，结构体（struct）不仅可以直接在main函数内部定义和使用，也可以定义为全局类型。访问结构体成员有两种主要方式：通过点运算符（.）**和**箭头运算符（->），这两种方式根据结构体变量是通过指针还是直接定义来决定。

1. 结构体类型定义

在这个示例中，我们使用了typedef为结构体Date创建了一个新的类型名，并定义了另一个结构体Person，如下所示：

• 结构体 Date 用于表示日期，包含三个整数类型的成员：day（日）、month（月）、year（年）。
• 结构体 Person 用于表示一个人的信息，包含字符串类型的成员name（姓名）、整数类型的成员age（年龄）以及浮点类型的成员height（身高）。

typedef struct Date {
    int day;
    int month;
    int year;
} Date;  // 可以直接使用Date作为类型名

struct Person {
    char name[50];
    int age;
    float height;
};

2. 创建结构体变量

可以通过以下方式创建结构体的变量并初始化：

Date today = {12, 2, 2024};  // 使用结构体类型Date创建变量today，并初始化其成员

在此，today是Date类型的变量，表示日期为2024年2月12日。

struct Person nix = {"Nix", 20, 175};  // 使用结构体类型Person创建变量nix并初始化

在此，nix是Person类型的变量，表示一个名为"Nix"、年龄为20岁、身高为175cm的人。

3. 访问结构体成员

有两种方式来访问结构体的成员：直接通过点运算符（.）和通过箭头运算符（->）来访问结构体指针指向的成员。

• 通过点运算符（.）： 点运算符用于访问结构体变量的成员，通常在结构体变量是直接定义的情况下使用。

printf("Today's date is : %d-%d-%d\n", today.year, today.month, today.day);

• 通过箭头运算符（->）： 箭头运算符用于通过指针访问结构体成员。它等效于(*pointer).member，但是更简洁。

Date* date_ptr = &today;  // 创建指向today的指针
printf("Accessed via pointer : %d-%d-%d\n", date_ptr->year, date_ptr->month, date_ptr->day);

这里，我们首先创建了一个指向today的指针date_ptr，然后使用箭头运算符来访问结构体成员。

4. 结构体成员访问示例

• 对于today结构体，使用点运算符直接访问它的成员：

printf("Today's date is : %d-%d-%d\n", today.year, today.month, today.day);

• 对于date_ptr指针，使用箭头运算符来访问它所指向的Date结构体的成员：

printf("Accessed via pointer : %d-%d-%d\n", date_ptr->year, date_ptr->month, date_ptr->day);

5. 输出人物信息

最后，我们创建了Person类型的结构体变量nix，并使用点运算符访问并打印它的成员：

printf("%s is %d years old and %.2f cm\n", nix.name, nix.age, nix.height);

总结

• 结构体变量可以通过点运算符（.）访问成员。
• 如果通过指针访问结构体成员，使用箭头运算符（->）。
• typedef可以为结构体定义别名，从而简化结构体类型的使用。

通过这种方式，我们可以灵活地操作和管理复杂的数据结构，使得程序更加清晰和易于维护。

---

178. 匿名结构体、函数参数为结构体

在C语言中，结构体可以非常灵活地使用，尤其是在函数参数和返回值中。除了通常的结构体类型声明，我们还可以使用匿名结构体（不显式定义结构体名称）以及通过值传递或引用传递来修改结构体的成员。以下是一些关键概念的介绍和示例。

1. 匿名结构体

匿名结构体是指在定义结构体时，不为结构体类型指定名称。虽然结构体成员仍然可以通过类型别名访问，但结构体本身没有名称。在这段代码中，我们使用typedef为结构体定义别名Student，但实际上它是一个完整的结构体类型。

typedef struct Student {	// 定义Student结构体
    char name[50];
    int id;
    float score;
} Student; // 结构体类型别名为Student

这里，Student是结构体类型的别名，省略了结构体名称。

2. 通过值传递更新结构体

函数可以通过值传递的方式来接收结构体。传递的是结构体的副本，修改副本不会影响原结构体。

void update_score_by_value(Student stu, float new_score) {
    stu.score = new_score;  // 只会修改副本的score，不会影响原结构体
}

• 调用：当我们调用update_score_by_value时，传递的是stu的副本，原结构体stu不会被修改。

update_score_by_value(stu, 100);

3. 通过引用传递更新结构体

为了修改原始结构体的内容，我们可以通过引用传递，即传递结构体的指针。这样可以直接操作内存中的数据。

void update_score_by_reference(Student* stu, float new_score) {
    stu->score = new_score;  // 直接修改原结构体的score值
}

• 调用：当我们调用update_score_by_reference时，传递的是stu的指针，通过该指针可以直接修改原结构体的内容。

update_score_by_reference(&stu, 100);

4. 示例代码解析

int main(void) {

    // 创建一个Student结构体变量，并初始化
    Student stu = { "John Doe", 123, 89.5 };

    // 打印更新前的学生信息
    puts("Before update:");
    print_stu(stu);

    // 通过值传递更新学生成绩
    puts("After update by value:\n");
    update_score_by_value(stu, 100);  // 这不会修改stu本身
    print_stu(stu);

    // 通过引用传递更新学生成绩
    update_score_by_reference(&stu, 100);  // 这会修改stu本身
    puts("After update by reference:");
    print_stu(stu);

    return 0;
}

• 初始时，stu的成绩为89.5。
• 调用update_score_by_value后，尽管成绩被更新为100，但是只修改了副本，stu本身并未改变。
• 调用update_score_by_reference后，stu的成绩真正被更新为100。

5. 输出结果

Before update:
Student Name: John Doe
Student ID: 123
Student Score: 89.50

After update by value:

Student Name: John Doe
Student ID: 123
Student Score: 89.50

After update by reference:
Student Name: John Doe
Student ID: 123
Student Score: 100.00

6. 总结

• 匿名结构体：虽然可以省略结构体名称，但可以通过typedef为其创建别名，方便在程序中使用。
• 值传递：通过函数参数传递结构体副本，函数内修改不会影响原始数据。
• 引用传递：通过指针传递结构体，使得函数可以直接修改原始结构体内容。

通过这些技术，我们可以灵活地处理结构体类型，在函数参数和返回值之间传递数据。

---

180. 结构体数组

在C语言中，结构体数组是存储多个结构体实例的数组，每个结构体实例都包含相同的数据成员。通过结构体数组，我们可以方便地组织和管理具有相同结构的数据。

1. 定义结构体数组

在本例中，我们定义了一个名为Point的结构体，表示二维坐标系中的点。然后创建了一个包含两个Point结构体实例的数组points，每个结构体实例初始化时指定了x和y的值。

typedef struct {
    int x;
    int y;
} Point;

Point points[2] = {
    {1, 2}, {3, 4}
};  // 定义一个包含2个Point结构体数组

• Point points[2]声明了一个包含两个Point类型元素的数组。
• {1, 2} 和 {3, 4} 是对这两个Point结构体实例的初始化，分别表示坐标 (1, 2) 和 (3, 4)。

2. 访问结构体数组元素

在结构体数组中，可以通过下标访问各个结构体元素，并通过结构体的成员名访问具体的成员数据。

for (int32_t i = 0; i < 2; i++) {
    printf("Point %d:(%d, %d)\n", i, points[i].x, points[i].y);
}

• points[i] 用来访问第i个Point结构体。
• points[i].x 和 points[i].y 用来访问该结构体的成员变量x和y。

3. 完整代码示例

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <inttypes.h>

typedef struct {
    int x;
    int y;
} Point;

int main(void) {
    // 定义并初始化结构体数组
    Point points[2] = {
        {1, 2}, {3, 4}
    };

    // 输出结构体数组的元素
    for (int32_t i = 0; i < 2; i++) {
        printf("Point %d:(%d, %d)\n", i, points[i].x, points[i].y);
    }
    
    return 0;
}

4. 输出结果

Point 0:(1, 2)
Point 1:(3, 4)

5. 总结

• 结构体数组允许我们存储多个结构体类型的实例，并且每个实例都可以有自己的成员变量。
• 通过下标访问数组元素，并通过点运算符访问结构体成员变量。
• 结构体数组对于存储和操作多个具有相同数据结构的数据非常有用。

---

181. 嵌套结构体

嵌套结构体是指在一个结构体内定义另一个结构体作为成员变量。通过嵌套结构体，我们可以将一个较为复杂的数据结构组织成多个子结构，每个子结构保存相关信息。这样做可以提高代码的可读性和结构化管理。

1. 嵌套结构体定义

在本例中，我们定义了两个结构体：Address 和 Person。Person 结构体包含了一个 Address 类型的成员，从而实现了嵌套结构体。

typedef struct {
    char street[50];
    char city[50];
    char country[50];
} Address;

typedef struct {
    char name[50];
    int age;
    Address address;  // 嵌套结构体
} Person;

• Address 结构体包含了三个字符串成员，分别用于表示街道、城市和国家。
• Person 结构体包含了姓名（name）、年龄（age）以及一个 Address 类型的 address 成员。这样，每个 Person 都可以拥有一个地址信息。

2. 嵌套结构体的使用

在 main 函数中，我们创建了一个 Person 类型的变量 nix，并为其成员（包括嵌套的 address 成员）赋了初值。

Person nix = {
    "Nix",
    20,
    {"STREET", "CITY", "COUNTRY"}
};

• nix 的 name 被赋值为 "Nix"，age 被赋值为 20。
• address 的成员（street、city 和 country）通过嵌套的花括号进行初始化。

3. 访问嵌套结构体的成员

对于嵌套结构体，可以通过两种方式访问成员：

• 通过点运算符 (.) 直接访问结构体成员。
• 通过指针和箭头运算符 (->) 访问结构体成员。

通过点运算符访问：

printf("Name: %s\n", nix.name);
printf("Age: %d\n", nix.age);
printf("Address: %s, %s, %s\n", nix.address.street, nix.address.city, nix.address.country);

通过指针和箭头运算符访问：

Person* ptr = &nix;
printf("Name: %s\n", ptr->name);
printf("Age: %d\n", ptr->age);
printf("Address: %s, %s, %s\n", ptr->address.street, ptr->address.city, ptr->address.country);

4. 完整代码示例

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <inttypes.h>

typedef struct {
    char street[50];
    char city[50];
    char country[50];
} Address;

typedef struct {
    char name[50];
    int age;
    Address address;  // 嵌套结构体
} Person;

int main(void) {
    // 创建Person类型的变量，并初始化
    Person nix = {
        "Nix", 
        20, 
        {"STREET", "CITY", "COUNTRY"}  // 嵌套结构体初始化
    };

    // 通过点运算符访问成员
    printf("Name: %s\n", nix.name);
    printf("Age: %d\n", nix.age);
    printf("Address: %s, %s, %s\n\n", nix.address.street, nix.address.city, nix.address.country);

    // 使用指针和箭头运算符访问结构体成员
    Person* ptr = &nix;
    printf("Name: %s\n", ptr->name);
    printf("Age: %d\n", ptr->age);
    printf("Address: %s, %s, %s\n", ptr->address.street, ptr->address.city, ptr->address.country);

    return 0;
}

5. 输出结果

Name: Nix
Age: 20
Address: STREET, CITY, COUNTRY

Name: Nix
Age: 20
Address: STREET, CITY, COUNTRY

6. 总结

• 嵌套结构体允许将一个结构体作为另一个结构体的成员，从而实现更复杂的数据组织。
• 通过点运算符 (.) 和箭头运算符 (->) 可以方便地访问结构体及其成员。
• 嵌套结构体非常适用于表示具有子结构的数据，例如一个人（Person）可以拥有一个地址（Address）。