Aexiar/c

Fork 0

mirror of https://github.com/Aexiar/c.git synced 2024-10-22 14:05:45 +02:00

许大仙 6e29fcae27 2024年10月11日 10:36

2024-10-11 02:36:57 +00:00

29 KiB

Raw Blame History

第一章：枚举（⭐）

1.1 回顾 C 语言中的变量

C 语言中的变量，按照数据类型划分，如下所示：

Note

构造类型也会被人称为自定义数据类型！！！

C 语言中的变量，按照声明位置划分，如下所示：

C 语言中的变量，按照存储方式分类，如下所示：

1.2 什么是枚举？

在实际生活中，我们经常会遇到一些数据的值是有限的，如：
- 星期：Monday (星期一)、......、Sunday (星期天)。
- 性别：Man (男)、Woman (女)。
- 季节：Spring (春节)......Winter (冬天)。
- 支付方式：Cash（现金）、WeChatPay（微信）、Alipay (支付宝)、BankCard (银行卡)、CreditCard (信用卡)。
- 就职状态：Busy、Free、Vocation、Dimission。
- 订单状态：Nonpayment（未付款）、Paid（已付款）、Delivered（已发货）、 Return（退货）、Checked（已确认）Fulfilled（已配货）。
- ...
类似上述的场景，我们就可以使用 C 语言提供的一种构造类型 --- 枚举（Enumeration），其用于定义一组相关的整型常量。它提供了一种更具可读性和可维护性的方式来定义常量集合。

1.3 定义枚举

语法：

enum 枚举类型 {
    枚举元素1, // 枚举常量1
    枚举元素2, // 枚举常量2
    ...
}

Note

枚举元素也称为枚举成员或枚举常量，具有如下的特点：

① 枚举元素的值必须在同一枚举中是唯一的。

② 枚举元素的值必须是整数类型，通常是 int 。

③ 如果没有为枚举元素指定值，编译器会自动为它们进行分配，从 0 开始，自动递增。

④ 定义枚举的时候，也可以为枚举元素自定义值，但是需要保证唯一性和整数类型。

Important

CLion 中选中枚举元素并使用快捷键 Ctrl + Q，或将鼠标悬浮在枚举元素上，就会自动显示枚举元素对应的值，如下所示：

示例：每个枚举常量的值默认为从 0 开始递增的整数

#include <stdio.h>

/**
 * 定义枚举
 */
enum Color {
    RED,   // 0
    GREEN, // 1
    BLUE   // 2
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

示例：定义带有显式值的枚举，如果给定一个常量的值，后续的常量会依次递增

#include <stdio.h>

/**
 * 定义枚举
 */
enum Color {
    RED = 1,
    GREEN, // 2
    BLUE   // 3
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    enum Color color = GREEN;
    printf("color = %d\n", color);

    return 0;
}

1.4 枚举变量

1.4.1 概述

定义变量时所指定的类型是我们自定义的枚举类型，那么该变量就称为枚举变量。

1.4.2 定义枚举变量

可以使用定义好的枚举类型来声明枚举变量。
语法：

enum 枚举名 变量名;

示例：

#include <stdio.h>

/**
 * 定义枚举
 */
enum Color {
    RED = 1,
    GREEN,
    BLUE
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);
    
    // 定义枚举变量
    enum Color color ; // [!code highlight]

    return 0;
}

1.4.3 给枚举变量赋值

枚举变量的值应该是枚举类型中的任意一个枚举元素（没有常量），不能是其他的值。
语法：

枚举变量 = 枚举常量;

示例：

#include <stdio.h>

/**
 * 定义枚举
 */
enum Color {
    RED = 1,
    GREEN,
    BLUE
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 给枚举变量赋值
    enum Color color = BLUE; // [!code highlight]
    
    printf("color = %d\n", color);

    return 0;
}

1.5 枚举的本质到底是什么？

尽管枚举的定义语法看起来像一种新类型，但它的底层实际上是一个整型（通常是 int 类型）。C 语言并不强制要求枚举使用特定的整型类型，但编译器通常会选择使用 int 来表示枚举。
在 C 语言中，枚举类型和整数类型是兼容的。你可以在需要整数的地方使用枚举值，也可以将枚举值赋给整型变量。这是因为枚举成员在编译时就被替换为其对应的整数值。
示例：

#include <stdio.h>

/**
 * 定义枚举
 */
enum Color {
    RED = 1,
    GREEN, // 2
    BLUE   // 3
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    enum Color color = 0;

    printf("sizeof(color) = %zu \n", sizeof(color)); // sizeof(color) = 4
    printf("sizeof(RED) = %zu \n", sizeof(RED));     // sizeof(RED) = 4
    printf("sizeof(GREEN) = %zu \n", sizeof(GREEN)); // sizeof(GREEN) = 4
    printf("sizeof(BLUE) = %zu \n", sizeof(GREEN));  // sizeof(BLUE) = 4
    printf("sizeof(int) = %zu \n", sizeof(int));     // sizeof(int) = 4

    return 0;
}

1.6 应用示例

如果枚举常量的值是连续的，我们可以使用循环遍历；如果枚举常量的值不是连续的，则无法遍历。
示例：

#include <stdio.h>
// 定义枚举类型
enum Weekday {
    MONDAY = 1,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
};
int main() {

    // 定义枚举变量
    enum Weekday day;

    // 使用循环遍历出所有的枚举常量
    for (day = MONDAY; day <= SUNDAY; day++) {
        printf("%d \n", day);
    }

    return 0;
}

1.7 应用示例

枚举变量通常用于控制语句中，如：switch 语句。
示例：

#include <stdio.h>

/**
 * 定义枚举
 */
enum Color {
    RED = 1,
    GREEN, // 2
    BLUE   // 3
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    enum Color color;
    
    printf("请输入颜色(1-3)：");
    scanf("%d", &color);
    switch (color) {
        case RED:
            printf("红色\n");
            break;
        case GREEN:
            printf("绿色\n");
            break;
        case BLUE:
            printf("蓝色\n");
            break;
        default:
            printf("输入错误\n");
            break;
    }

    return 0;
}

第二章：结构体（⭐）

2.1 概述

C 语言内置的数据类型，除了几种原始的基本数据类型，只有数组属于复合类型，可以同时包含多个值，但是只能包含相同类型的数据，实际使用场景受限。

2.2 为什么需要结构体？

2.2.1 需求分析 1

现有一个需求，编写学生档案管理系统，这里需要描述一个学生的信息。该学生的信息包括学号、姓名、性别、年龄、家庭住址等，这些数据共同说明一个学生的总体情况。

显然，这些数据类型各不相同，无法使用数组进行统一管理。

2.2.2 需求分析 2

隔壁老王养了两只猫咪。一只名字叫小黄，今年 2 岁，橘色；另一只叫小黑，今年 3 岁，黑色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示老王没有这只猫。

2.2.3 传统的解决方案

尝试 ① ：单独定义多个变量存储，实现需求，但是，多个变量，不便于数据的管理。
尝试 ② ：使用数组，它是一组具有相同类型的数据的集合。但在编程中，往往还需要一组类型不同的数据，例如：猫的名字使用字符串、年龄是 int，颜色是字符串，因为数据类型不同，不能用一个数组来存放。
尝试 ③ ：C 语言提供了结构体。使用结构体，内部可以定义多个不同类型的变量作为其成员。

2.3 什么是结构体

C 语言提供了 struct 关键字，允许自定义复合数据类型，将不同类型的值组合在一起，这种类型称为结构体（structure）类型。

Note

C 语言没有其他语言的对象（object）和类（class）的概念，struct 结构很大程度上提供了对象和类的功能。

2.4 结构体的基本使用

2.4.1 声明结构体

语法：

struct 结构体名{
    数据类型1 成员名1;   // 分号结尾
    数据类型2 成员名2;
    ……
    数据类型n 成员名n;
};

Note

结构体中可以包含以下数据类型：

① 基本数据类型：整型、浮点型、字符型、布尔型。

② 指针类型。

③ 枚举类型。

④ 结构体类型：

可以包含其他结构体作为成员（称为嵌套结构体）。

结构体指针。

⑤ 联合体类型。

⑥ 位域。

示例：

#include <stdio.h>

/**
 * 声明学生的结构体
 */
struct Student {
    int  id;          // 学号
    char name[20];    // 姓名
    char gender;      // 性别
    int  age;         // 年龄
    char address[50]; // 地址
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明猫的结构体
 */
struct Cat {
    char name[20];  // 姓名
    int  age;       // 年龄
    char color[50]; // 颜色
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明人类的结构体
 */
struct Person {
    char   name[20]; // 姓名
    char   gender;   // 性别
    int    age;      // 年龄
    double weight;   // 体重
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明通讯录的结构体
 */
struct Contact {
    char name[50];        // 姓名
    int  year;            // 年
    int  month;           // 月
    int  day;             // 日
    char email[100];      // 电子邮箱
    char phoneNumber[15]; // 手机号
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明员工的结构体
 */
struct Employee {
    int  id;          // 员工编号
    char name[20];    // 员工姓名
    char gender;      // 员工性别
    int  age;         // 员工年龄
    char address[30]; // 员工住址
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

2.4.2 定义结构体变量

2.4.2.1 概述

定义了新的数据类型（结构体类型）以后，就可以定义该类型的变量，这与定义其他类型变量的写法是一样的。

2.4.2.2 方式一

语法：

struct 结构体类型名称 结构体变量名;

Note

① 需要先定义结构体，然后再定义结构体变量。

② struct 关键字不能省略；否则， C 语言编译器将会报错。

Caution

在 C 语言中，结构体（struct）和结构体变量是两个不同的概念，如下所示：

① 结构体是一种自定义的数据类型，像一种模板，定义了数据的格式，不占用内存空间。

② 结构体变量是根据结构体类型创建的变量，代表了一个具体的对象，用于存储数据，需要内存空间来存储。

示例：

#include <stdio.h>

/**
 * 声明学生的结构体
 */
struct Student {
    int  id;          // 学号
    char name[20];    // 姓名
    char gender;      // 性别
    int  age;         // 年龄
    char address[50]; // 地址
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 定义学生结构体的变量
    struct Student student; // [!code highlight]

    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明猫的结构体
 */
struct Cat {
    char name[20];  // 姓名
    int  age;       // 年龄
    char color[50]; // 颜色
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 定义猫结构体的变量
    struct Cat cat; // [!code highlight]
    
    return 0;
}

2.4.2.3 方式二

语法：

struct 结构体名{
    数据类型1 成员名1;   // 分号结尾
    数据类型2 成员名2;
    ……
    数据类型n 成员名n;
} 结构体变量1，结构体变量2,...;

Note

在声明结构体的同时定义结构体变量。

示例：

#include <stdio.h>

/**
 * 声明学生的结构体的同时定义结构体变量
 */
struct Student {
    int  id;          // 学号
    char name[20];    // 姓名
    char gender;      // 性别
    int  age;         // 年龄
    char address[50]; // 地址
} stu1,stu2; // stu1 和 stu2 是结构体变量

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明猫的结构体的同时定义结构体变量
 */
struct Cat {
    char name[20];  // 姓名
    int  age;       // 年龄
    char color[50]; // 颜色
} cat; // cat 是结构体变量

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

2.4.2.4 方式三

语法：

struct {
    数据类型1 成员名1;   // 分号结尾
    数据类型2 成员名2;
    ……
    数据类型n 成员名n;
} 结构体变量1，结构体变量2,...;

Note

① 在声明结构体的同时定义结构体变量，但是不给结构体名，这种方式的结构体也称为匿名结构体。

② 和方式二相比，后面的代码将无法通过该结构体来定义变量，因为没有结构体名称，除非使用 typedef 关键字。

示例：

#include <stdio.h>

/**
 * 声明学生的结构体的同时定义结构体变量
 */
struct {
    int  id;          // 学号
    char name[20];    // 姓名
    char gender;      // 性别
    int  age;         // 年龄
    char address[50]; // 地址
} stu1,stu2; // stu1 和 stu2 是结构体变量

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明猫的结构体的同时定义结构体变量
 */
struct {
    char name[20];  // 姓名
    int  age;       // 年龄
    char color[50]; // 颜色
} cat; // cat 是结构体变量

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    return 0;
}

2.4.3 结构体变量中成员的获取和赋值

2.4.3.1 概述

成员是结构体的一个组成部分，一般是基本数据类型、也可以是数组、指针、结构体等。结构体的成员也可以称为属性。
结构体和数组类似，也是一组数据的集合，结构体使用点号 . 获取单个成员，可以进行赋值和取值。

2.4.3.2 结构体成员逐个赋值

语法：

结构体变量名.成员名 = 值; // 值可以是常量或变量

示例：

#include <stdio.h>
#include <string.h>

/**
 * 声明人类的结构体
 */
struct Person {
    char   name[20]; // 姓名
    char   gender;   // 性别
    int    age;      // 年龄
    double weight;   // 体重
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 定义猫结构体的变量
    struct Person person;

    // 结构体变量中成员赋值
    strcpy(person.name, "张三");
    person.gender = 'M';
    person.age    = 20;
    person.weight = 60.5;

    // 结构体变量中成员的访问
    printf("姓名：%s\n", person.name);     // 姓名：张三
    printf("性别：%c\n", person.gender);   // 性别：M
    printf("年龄：%d\n", person.age);      // 年龄：20
    printf("体重：%.2f\n", person.weight); // 体重：60.50

    return 0;
}

示例：

#include <stdio.h>
#include <string.h>

/**
 * 声明学生的结构体
 */
struct Student {
    int  id;          // 学号
    char name[20];    // 姓名
    char gender;      // 性别
    int  age;         // 年龄
    char address[50]; // 地址
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 定义学生结构体的变量
    struct Student student;

    // 结构体变量中成员赋值
    student.id = 10001;
    strcpy(student.name, "张三");
    student.gender = 'M';
    student.age    = 20;
    strcpy(student.address, "北京市海淀区");

    // 输出结构体变量中成员的值
    printf("学号: %d\n", student.id);      // 学号: 10001
    printf("姓名: %s\n", student.name);    // 姓名: 张三
    printf("性别: %c\n", student.gender);  // 性别: M
    printf("年龄: %d\n", student.age);     // 年龄: 20
    printf("地址: %s\n", student.address); // 地址: 北京市海淀区

    return 0;
}

2.4.3.3 使用大括号一次性对结构体所有成员赋值

语法：

struct 结构体类型 结构体变量 = {...};

struct 结构体类型 结构体变量 = {.成员 = xxx,...};

Note

① struct 结构体类型结构体变量 = {...};，需要和声明结构体中成员的顺序保持一致。

② struct 结构体类型结构体变量 = {.成员 = xxx,...}; ，不需要和声明结构体中成员的顺序保持一致。

③ 如果初始化的属性少于声明时的属性，剩下的那些属性都会初始化为 0 。

Important

CLion 中其实是有这类语法提示的，如下所示：

示例：

#include <stdio.h>
#include <string.h>

/**
 * 声明学生的结构体
 */
struct Student {
    int  id;          // 学号
    char name[20];    // 姓名
    char gender;      // 性别
    int  age;         // 年龄
    char address[50]; // 地址
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 定义学生结构体的变量并进行初始化
    struct Student student = {10001, "张三", 'M', 20, "北京市海淀区"}; // [!code highlight]

    // 输出结构体变量中成员的值
    printf("学号: %d\n", student.id);      // 学号: 10001
    printf("姓名: %s\n", student.name);    // 姓名: 张三
    printf("性别: %c\n", student.gender);  // 性别: M
    printf("年龄: %d\n", student.age);     // 年龄: 20
    printf("地址: %s\n", student.address); // 地址: 北京市海淀区

    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明人类的结构体
 */
struct Person {
    char   name[20]; // 姓名
    char   gender;   // 性别
    int    age;      // 年龄
    double weight;   // 体重
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 定义人类结构体的变量并进行初始化
    struct Person person = {.gender = 'M', 
                            .name = "张三",
                            .age = 15,
                            .weight = 60.5}; 

    // 结构体变量中成员的访问
    printf("姓名：%s\n", person.name);     // 姓名：张三
    printf("性别：%c\n", person.gender);   // 性别：M
    printf("年龄：%d\n", person.age);      // 年龄：20
    printf("体重：%.2f\n", person.weight); // 体重：60.50

    return 0;
}

2.4.4 应用示例

需求：创建一个 Box 的结构体，在其中定义三个成员分别表示一个立方体的长、宽和高（长、宽、高可以由控制台输入），并且定义一个函数获取立方体的体积。
示例：

#include <stdio.h>

/**
 * 声明 Box 的结构体
 */
struct Box {
    double length; // 长
    double width;  // 年龄
    double height; // 高度
};

/**
 * 获取 Box 的体积
 * @param box
 * @return
 */
double getVolume(struct Box box) {
    return box.length * box.width * box.height;
}

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 创建结构体变量
    struct Box box;

    // 输入
    printf("请输入长：");
    scanf("%lf", &box.length);
    printf("请输入宽：");
    scanf("%lf", &box.width);
    printf("请输入高：");
    scanf("%lf", &box.height);

    // 调用函数获取体积
    printf("体积为：%.2lf\n", getVolume(box));

    return 0;
}

2.4.5 总结

结构体是一个自定义数据类型（构造类型），表示的是一种数据类型。
结构体变量就是一个具体的变量，例如：

int num = 10; // int 是数据类型，而 num 是一个具体的 int 类型的变量

struct Car car ; // Car 是结构体数据类型，而 car 是一个具体的 Car 类型的变量

Note

结构体就相当于是一个汽车图纸，是一个模板。而生产出来的具体的一辆辆的汽车，就类似于一个个的结构体变量。这些结构体变量都含有相同的成员，将结构体变量的成员比作“零件”，同一张图纸生产出来的零件的作用都是一样的。

如果学过 Java 等面向对象的语言，就可以将结构体当做是类，而结构体变量当做是对象。但是，两者不是完全等价，因为其底层的内存结构是不一样的。

2.5 进一步认识结构体

2.5.1 结构体嵌套

之前说过，结构体中的成员可以包含以下数据类型：
- ① 基本数据类型：整型、浮点型、字符型、布尔型。
- ② 指针类型。
- ③ 枚举类型。
- ④ 结构体类型：
  - 可以包含其他结构体作为成员（称为嵌套结构体）。
  - 结构体指针。
- ⑤ 联合体类型。
- ⑥ 位域。
如果一个结构体的成员中是另外一个结构体，那么就构成了结构体嵌套。

Important

也许，你会有疑问，为什么结构体中的成员不能包含自己，如下所示：
struct A {
    int data;
    struct A self; // 错误，结构体不能包含自己
};
原因之一是内存分配问题，即：编译器会试图计算结构体A的大小，但是因为A中包含另一个A，这个A中又包含另一个A，这种嵌套会无限递归下去。编译器无法确定最终的大小，因为这个定义永远不会结束。

原因之二是逻辑上的循环问题，即：如果结构体包含自己，这意味着每个结构体实例会包含另一个结构体实例，后者又包含另一个结构体实例，导致逻辑上的循环引用。这是不可能实现的，因为系统的内存和逻辑不能支持这种无穷递归。

解决方案：虽然不能直接包含自己，但是可以通过指针来引用自身。指针有固定的大小（通常是4字节或8字节，取决于系统架构），因此不会造成上述的无限递归问题。

示例：

#include <stdio.h>
#include <string.h>

/**
 * 声明姓名结构体
 */
struct Name { 
    char firstName[50];
    char lastName[50];
};

/**
 * 声明学生的结构体
 */
struct Student {
    int         id;          // 学号
    struct Name name;        // 姓名
    char        gender;      // 性别
    int         age;         // 年龄
    char        address[50]; // 地址
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 定义结构体变量并赋值
    struct Student stu1 = {1001, {"张", "三"}, 'M', 20, "北京市海淀区"};

    printf("学号: %d\n", stu1.id);
    printf("姓名: %s\n", strcat(stu1.name.firstName, stu1.name.lastName));
    printf("性别: %c\n", stu1.gender);
    printf("年龄: %d\n", stu1.age);
    printf("地址: %s\n", stu1.address);

    printf("\n");

    // 定义结构体变量并赋值
    struct Name    name = {.firstName = "李", .lastName = "四"};
    struct Student stu2 = {1002, name, 'F', 21, "上海市浦东新区"};
    printf("学号: %d\n", stu2.id);
    printf("姓名: %s\n", strcat(stu2.name.firstName, stu2.name.lastName));
    printf("性别: %c\n", stu2.gender);
    printf("年龄: %d\n", stu2.age);
    printf("地址: %s\n", stu2.address);
    return 0;
}

示例：

#include <stdio.h>

/**
 * 声明日期的结构体
 */
struct Date {
    int year;
    int month;
    int day;
};

/**
 * 声明员工的结构体
 */
struct Employee {
    int         id;          // 员工编号
    char        name[20];    // 员工姓名
    char        gender;      // 员工性别
    int         age;         // 员工年龄
    char        address[30]; // 员工住址
    struct Date hireDate;    // 员工的入职时间
};

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // 定义员工结构体的变量
    struct Employee employee = {1001, "张三", 'M', 20, "北京市海淀区", 
                                {2018, 10, 1}};

    printf("员工编号: %d\n", employee.id);
    printf("员工姓名: %s\n", employee.name);
    printf("员工性别: %c\n", employee.gender);
    printf("员工年龄: %d\n", employee.age);
    printf("员工住址: %s\n", employee.address);
    printf("入职时间: %d-%d-%d\n", employee.hireDate.year
           , employee.hireDate.month, employee.hireDate.day);

    printf("\n");

    // 定义员工结构体的变量
    struct Date     hireDate  = {2019, 10, 1};
    struct Employee employee2 = {.id = 1002, 
                                 .name = "李四", 
                                 .gender = 'F', 
                                 .age = 21, 
                                 .address = "上海市浦东新区"};
    employee2.hireDate        = hireDate;
    printf("员工编号: %d\n", employee2.id);
    printf("员工姓名: %s\n", employee2.name);
    printf("员工性别: %c\n", employee2.gender);
    printf("员工年龄: %d\n", employee2.age);
    printf("员工住址: %s\n", employee2.address);
    printf("入职时间: %d-%d-%d\n", employee2.hireDate.year, 
           employee2.hireDate.month, employee2.hireDate.day);

    return 0;
}

2.5.2 结构体占用的内存空间

2.5.2.1 概述

假设结构体变量是这样定义的，如下所示：

struct Student{ 
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在学习小组
    float score;  //成绩
} stu1,stu2 ;

理论上讲结构体变量的各个成员在内存中是连续存储的，和数组类似，如：上面的结构体变量 stu1 和 stu2 的内存分布，如下所示：

我们也可以通过代码，来验证：

#include <stdio.h>

struct Student { 
    char *name;  // 姓名
    int   num;   // 学号
    int   age;   // 年龄
    char  group; // 所在学习小组
    float score; // 成绩
} stu1, stu2;

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // sizeof(stu1.name) = 8
    printf("sizeof(stu1.name) = %zu\n", sizeof(stu1.name));
    // sizeof(stu1.num) = 4
    printf("sizeof(stu1.num) = %zu\n", sizeof(stu1.num));     
    // sizeof(stu1.age) = 4
    printf("sizeof(stu1.age) = %zu\n", sizeof(stu1.age)); 
    // sizeof(stu1.group) = 1
    printf("sizeof(stu1.group) = %zu\n", sizeof(stu1.group)); 
    // sizeof(stu1.score) = 4
    printf("sizeof(stu1.score) = %zu\n", sizeof(stu1.score)); 

    // total = 21
    printf("total = %zu\n", sizeof(stu1.name) 
           + sizeof(stu1.num) 
           + sizeof(stu1.age) 
           + sizeof(stu1.group) 
           + sizeof(stu1.score));

    return 0;
}

但是，在编译器的具体实现中，各个成员之间可能会存在缝隙，对于 stu1 和 stu2 来说，成员变量 group 和 score 之间存在 3 个字节的空白填充，如下所示：

我们也可以通过代码，来验证：

#include <stdio.h>

struct Student { // 没有写 stu
    char *name;  // 姓名
    int   num;   // 学号
    int   age;   // 年龄
    char  group; // 所在学习小组
    float score; // 成绩
} stu1, stu2;

int main() {

    // 禁用 stdout 缓冲区
    setbuf(stdout, nullptr);

    // sizeof(stu1.name) = 8
    printf("sizeof(stu1.name) = %zu\n", sizeof(stu1.name));
    // sizeof(stu1.num) = 4
    printf("sizeof(stu1.num) = %zu\n", sizeof(stu1.num));     
    // sizeof(stu1.age) = 4
    printf("sizeof(stu1.age) = %zu\n", sizeof(stu1.age)); 
    // sizeof(stu1.group) = 1
    printf("sizeof(stu1.group) = %zu\n", sizeof(stu1.group)); 
    // sizeof(stu1.score) = 4
    printf("sizeof(stu1.score) = %zu\n", sizeof(stu1.score)); 

    // total = 21
    printf("total = %zu\n", sizeof(stu1.name) 
           + sizeof(stu1.num) 
           + sizeof(stu1.age) 
           + sizeof(stu1.group) 
           + sizeof(stu1.score));

    // sizeof(stu1) = 24
    printf("sizeof(stu1) = %zu\n", sizeof(stu1)); 

    return 0;
}

至于结构体变量中的各个成员变量，为什么会存在“裂缝”，就是因为内存对齐。

29 KiB

Raw Blame History

第一章：枚举（⭐）

1.1 回顾 C 语言中的变量

1.2 什么是枚举？

1.3 定义枚举

1.4 枚举变量

1.4.1 概述

1.4.2 定义枚举变量

1.4.3 给枚举变量赋值

1.5 枚举的本质到底是什么？

1.6 应用示例

1.7 应用示例

第二章：结构体（⭐）

2.1 概述

2.2 为什么需要结构体？

2.2.1 需求分析 1

2.2.2 需求分析 2

2.2.3 传统的解决方案

2.3 什么是结构体

2.4 结构体的基本使用

2.4.1 声明结构体

2.4.2 定义结构体变量

2.4.2.1 概述

2.4.2.2 方式一

2.4.2.3 方式二

2.4.2.4 方式三

2.4.3 结构体变量中成员的获取和赋值

2.4.3.1 概述

2.4.3.2 结构体成员逐个赋值

2.4.3.3 使用大括号一次性对结构体所有成员赋值

2.4.4 应用示例

2.4.5 总结

2.5 进一步认识结构体

2.5.1 结构体嵌套

2.5.2 结构体占用的内存空间

2.5.2.1 概述

2.5.2.2 内存对齐

第三章：共用体

29 KiB Raw Blame History Unescape Escape

第一章：枚举（⭐）

1.1 回顾 C 语言中的变量

1.2 什么是枚举？

1.3 定义枚举

1.4 枚举变量

1.4.1 概述

1.4.2 定义枚举变量

1.4.3 给枚举变量赋值

1.5 枚举的本质到底是什么？

1.6 应用示例

1.7 应用示例

第二章：结构体（⭐）

2.1 概述

2.2 为什么需要结构体？

2.2.1 需求分析 1

2.2.2 需求分析 2

2.2.3 传统的解决方案

2.3 什么是结构体

2.4 结构体的基本使用

2.4.1 声明结构体

2.4.2 定义结构体变量

2.4.2.1 概述

2.4.2.2 方式一

2.4.2.3 方式二

2.4.2.4 方式三

2.4.3 结构体变量中成员的获取和赋值

2.4.3.1 概述

2.4.3.2 结构体成员逐个赋值

2.4.3.3 使用大括号一次性对结构体所有成员赋值

2.4.4 应用示例

2.4.5 总结

2.5 进一步认识结构体

2.5.1 结构体嵌套

2.5.2 结构体占用的内存空间

2.5.2.1 概述

2.5.2.2 内存对齐

第三章：共用体

29 KiB

Raw Blame History