# 一、结构体

1. **结构体基本概念**

- C语言提供了众多的基本类型，但现实生活中的对象一般都不是单纯的整型、浮点型或字符串，而是这些基本类型的综合体。比如一个学生，典型地应该拥有学号（整型）、姓名（字符串）、分数（浮点型）、性别（枚举）等不同层面的属性，这些所有的属性都不应该被拆分开来，而是应该组成一个整体，代表一个完整的学生。

- 在C语言中，可以使用结构体来将多种不同的数据类型组装起来，形成某种具有现实意义的自定义的变量类型。结构体本质上是一种自定义类型。

- 结构体跟普通变量一样，涉及定义、初始化、赋值、取址、传值等等操作，这些操作绝大部分与普通变量操作并无二致，只有少数操作有特殊性。

- **结构体定义**

```c
struct 结构体标签
{
    成员1;
    成员2;
    ...
};
```

- 语法

- struct关键字，用于声明定义结构体

- 结构体标签，用于区分各个不同的结构体

- 成员，是包含在结构体内部的数据，可以是任意的数据类型（不能是自己类型的普通变量但可以是自己类型指针变量）。

```c
// 定义了一种称为struct A的结构体类型
struct A  // struct A 是一个自定义的类型
{
    int a;
    char b;
    double c;
};

// 定义了一种称为struct student的结构体类型
struct student 
{
    char name[20];  // 姓名
    int id;         // 学号
    char *sex;      // 性别
    short age;      // 年龄
    struct A a;     // 其他类型的结构体变量
    // struct student b; // 不能定义自己类型的结构体普通变量(递归申请空间)，作为自己的成员
    struct student *p; // 能定义自己类型的结构体指针变量(指针的内存空间只有系统字长有关)，作为自己的成员
    //...
};

int main(void)
{
    // 定义一个int类型变量
    int num;  // int 数据类型  num变量名称
    //定义了一个struct student （结构体）类型变量
    struct student zsf; // struct student 数据类型 zsf变量的名称
}
```

- **结构体初始化**

- 由于结构内部拥有多个不同类型的成员，因此采用与数组初始化类似的列表形式进行

- 初始化方式：普通初始化，指定成员初始化

- 一般推荐使用指定成员初始化，方便适应结构体类型的升级迭代

- 声明定义与初始化一体

```c
// 定义一个结构体类型
// 定义一个结构体类型
struct A
{
    int a;
    char b;
    double c;
}tmp = {
    100,'S',3.14
},// 定义一个结构体变量tmp并使用普通初始化方式初始化tmp成员
bbk={
    .a=500,
    .b='C'
}; // 定义一个结构体变量bbk并使用指定成员初始化方式初始化bbk成员
```

**注意：**

- 定义时初始化

```c
    struct A xyz = {120,"w", 6.25}; // 普通初始化
    struct A jjk = {.b="w",.a=120, }; // 指定成员初始化
```

- 指定成员初始化的好处：

- 成员初始化顺序可以改变

- 可以只初始化一部分成员

- 结构体新增成员后初始化语句仍然可用。

- **结构体成员引用**

- 结构体相当于一个集合，内部包含了众多成员，每一个成员都是一个独立的变量，都可以独立地引用，引用结构体成员使用一个成员引用符'.'即可：

```c
结构体变量名称.成员名称
```

```c
    struct A kkl;
    kkl.a=866;
    kkl.b='L';
    kkl.c=9.36;

    printf("a=%d b=%c c=%f\n", kkl.a, kkl.b, kkl.c);
```

## 练习

定义书籍结构体(书名、作者、售价)并定义三本书，分别使用普通初始化、指定成员初始化与结构体引用三种方式给三本书赋值属性后在终端展示

1. **结构体指针与数组**

- 结构体指针

```c
struct student
{
    unsigned char *name;
    unsigned long id;
    unsigned char *sex;
    unsigned char age;
};

struct student *zh = malloc(sizeof(struct student)); // 定义一个结构体指针变量

    (*zh).name = "张三丰";  // (*). == ->
    (*zh).id = 10086;
    (*zh).sex = "男";
    (*zh).age = 18;

    printf("%s %ld %s %d\n", zh->name, zh->id, zh->sex, zh->age);
```

注意：结构体指针访问结构体成员时使用 -> 

- 结构体数组

```c
    // struct student wang[3] = {
    //                             "王局", 10010, "女", 17,
    //                             "王麻", 10000, "男",19,
    //                             "王铁", 10001, "男",19
    //                          };  // 普通初始化
    //  struct student wang[3] = {
    //                            [1]= "王局", 10010, "女", 17,
    //                            [0]= "王麻", 10000, "男",19,
    //                            [2]= "王铁", 10001, "男",19
    //                          }; // 指定元素普通初始化
     struct student wang[3] = {
                                [2].name="王局", [0].id=10010, [1].sex="女",[0].age=17,
                                // "王麻", 10000, "男",19,
                                // "王铁", 10001, "男",19
                             };  // 指定成员初始化
    for (int i = 0; i < sizeof(wang)/sizeof(wang[0]); i++)
    {
        printf("%s %ld %s %d\n", wang[i].name, wang[i].id, wang[i].sex, wang[i].age);  // 访问结构体数组元素
    }
```

# 练习1

升级书籍管理系统功能，添加作者与售价属性，并将功能进行完善（如查找书籍可分为书名查找，按作者查找，按售价查找）

1. **typedef**

- 在 C 语言中，typedef关键字用于为已有的数据类型创建别名，增强代码的可读性、可维护性和可移植性。

- **基本应用：为基本数据类型创建别名**

- 为内置数据类型（如int、char等）定义更具描述性的名称，使代码意图更清晰。

```c
typedef int Age;       // 为int创建别名Age
typedef float Weight;  // 为float创建别名Weight

Age user_age = 25;
Weight apple_weight = 0.3f;

```

- **为复杂类型创建简化别名**

（1）指针类型

简化指针类型的声明，尤其适合频繁使用的指针类型。

```c
typedef int* IntPtr;  // 为int*创建别名IntPtr
IntPtr p1, p2;        // 等价于int *p1, *p2;（避免遗漏*的问题）
```

（2）数组类型

为固定大小的数组定义别名，减少重复代码。

```c
typedef int IntArray[10];  // 为"int[10]"创建别名IntArray
IntArray arr;              // 等价于int arr[10];
```

（3）结构体 / 联合体

简化结构体 / 联合体的使用，无需每次加

```c
// 传统方式
struct Student {
    char name[20];
    int id;
};
struct Student s1;  // 必须加struct

// 使用typedef
typedef struct {
    char name[20];
    int id;
} Student;
Student s2;  // 直接使用别名，更简洁
```

- **为函数指针创建别名**

函数指针语法复杂，

```c
// 为"int (*)(int, int)"类型创建别名CalcFunc
typedef int (*CalcFunc)(int, int);

// 定义符合该类型的函数
int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

// 使用别名声明函数指针变量
CalcFunc func = add;
printf("%d\n", func(2, 3));  // 输出5
func = mul;
printf("%d\n", func(2, 3));  // 输出6
```

- **提高代码可移植性**

在跨平台开发中，不同系统的基础类型可能有差异（如

```c
// 在32位系统可能定义为：
typedef int int32;
// 在16位系统可能定义为：
typedef long int32;

// 代码中直接使用int32，无需关心底层实现
int32 value = 100;
```

-  **增强代码可读性和可维护性**

- 通过别名直观表达变量的含义（如Age比int更清晰）。

- 当需要修改类型时，只需修改typedef处，无需全局替换（如将typedef int Age改为typedef long Age）。

- **总结**

- typedef的核心作用是为数据类型创建别名，主要价值体现在：

- 简化复杂类型（如结构体、函数指针）的使用；

- 提高代码的可读性和可维护性；

- 增强跨平台代码的可移植性。

1. **CPU字长**

- 字长的概念指的是处理器在一条指令中的数据处理能力，当然这个能力还需要搭配操作系统的设定，比如常见的32位系统、64位系统，指的是在此系统环境下，处理器一次存储处理的数据可以达32位或64位。

![](images/WEBRESOURCEae70b1f84fef405a968b6584513809aestickPicture.png)

CPU字长的含义

1. **地址对齐**

- CPU字长确定之后，相当于明确了系统每次存取内存数据时的边界，以32位系统为例，32位意味着CPU每次存取都以4字节为边界，因此每4字节可以认为是CPU存取内存数据的一个单元。

- 如果存取的数据刚好落在所需单元数之内，那么我们就说这个数据的地址是对齐的，如果存取的数据跨越了边界，使用了超过所需单元的字节，那么我们就说这个数据的地址是未对齐的。

![](images/WEBRESOURCE0486404994804c5fb05039cff405656astickPicture.png)

地址未对齐的情形

![](images/WEBRESOURCE886cfc7eae684a52b78b24c37be08569stickPicture.png)

地址已对齐的情形

- 从图中可以明显看出，数据本身占据了8个字节，在地址未对齐的情况下，CPU需要分3次才能完整地存取完这个数据，但是在地址对齐的情况下，CPU可以分2次就能完整地存取这个数据。

![](images/WEBRESOURCEe2dc42a51771304b30e561af3f2ed294image.png)

> 总结：如果一个数据满足以最小单元数存放在内存中，则称它地址是对齐的，否则是未对齐的。地址对齐的含义用大白话说就是1个单元能塞得下的就不用2个；2个单元能塞得下的就不用3个。如果发生数据地址未对齐的情况，有些系统会直接罢工，有些系统则降低性能。


1. **普通变量的m值**

- 以32位系统为例，由于CPU存取数据总是以4字节为单元，因此对于一个尺寸固定的数据而言，当它的地址满足某个数的整数倍时，就可以保证地址对齐。这个数就被称为变量的m值。根据具体系统的字长，和数据本身的尺寸，m值是可以很简单计算出来的。

- 举例：

```c
 char   c; // 由于c占1个字节，因此c不管放哪里地址都是对齐的，因此m=1
 short  s; // 由于s占2个字节，因此s地址只要是偶数就是对齐的，因此m=2
 int    i; // 由于i占4个字节，因此只要i地址满足4的倍数就是对齐的，因此m=4
 double f; // 由于f占8个字节，因此只要f地址满足4的倍数就是对齐的，因此m=4
 ​
 printf("%p\n", &c); // &c = 1*N，即：c的地址一定满足1的整数倍
 printf("%p\n", &s); // &s = 2*N，即：s的地址一定满足2的整数倍
 printf("%p\n", &i); // &i = 4*N，即：i的地址一定满足4的整数倍
 printf("%p\n", &f); // &f = 4*N，即：f的地址一定满足4的整数倍
```

- 注意，变量的m值跟变量本身的尺寸有关，但它们是两个不同的概念。

- 手工干预变量的m值：

```c
 char c __attribute__((aligned(32))); // 将变量 c 的m值设置为32
```

- 语法：

- attribute 机制是GNU特定语法，属于C语言标准语法的扩展。

- attribute 前后都是双下划线，aligned两边是双圆括号。

- attribute 语句，出现在变量定义语句中的分号前面，变量标识符后面。

- attribute 机制支持多种属性设置，其中 aligned 用来设置变量的 m 值属性。

- 一个变量的 m 值只能提升，不能降低，且只能为正的2的n次幂。

1. **结构体的M值**

- 概念：

- 结构体的M值，取决于其成员的m值的最大值。即：M = max{m1, m2, m3, …};

- 结构体的和地址和尺寸，都必须等于M值的整数倍。

- 示例：

```c
 struct node
 {
     short  a; // 尺寸=2，m值=2
     double b; // 尺寸=8，m值=4
     char   c; // 尺寸=1，m值=1
 };
 ​
 struct node n; // M值 = max{2, 4, 1} = 4;
```

- 以上结构体成员存储分析：

1. 结构体的M值等于4，这意味着结构体的地址、尺寸都必须满足4的倍数。

1. 成员a的m值等于2，但a作为结构体的首元素，必须满足M值约束，即a的地址必须是4的倍数

1. 成员b的m值等于4，因此在a和b之间，需要填充2个字节的无效数据（一般填充0）

1. 成员c的m值等于1，因此c紧挨在b的后面，占一个字节即可。

1. 结构体的M值为4，因此成员c后面还需填充3个无效数据，才能将结构体尺寸凑足4的倍数。

- 以上结构体成员图解分析：

![](images/WEBRESOURCEf305530c183d4d1682bc4b1fe628e14fstickPicture.png)

结构体成员布局

## 练习

计算下面结构体的大小

```c
struct s1
{
    int a;   
    char b;  
    int c;  
};

struct s2
{
    char a;
    char b;
    int c;  
};

struct s3
{
    int a;     
    double b;  
    int c;    
}; 

struct s4
{
    char a; 
    char b;  
    char c;  
};

struct s5
{
    char a;  
    short b; 
    int c;  
    double d;
};

struct s6
{
    char a;  
    short b; 
    int c;   
    struct s4 d; 
};
```

[32、64位数据类型占用字节以及内存对齐原理](https://developer.aliyun.com/article/979533)

**位域：**

```c
 struct n
 {
    int a:1;  // 一共是32位，只需要1位   m=4
    int b:4;  // 一共是32位，只需要4位
    int c:2;  // 一共是32位，只需要2位
 };
```

注意：位域的类型只能是整数类型（char、short、long、long long）

1. **可移植性**

可移植指的是相同的一段数据或者代码，在不同的平台中都可以成功运行。

- 对于数据来说，有两方面可能会导致不可移植：

- 数据尺寸发生变化

- 数据位置发生变化

- 第一个问题，起因是基本的数据类型在不同的系统所占据的字节数不同造成的，解决办法是使用讨论过的可移植性数据类型即可。接下来讨论第二个问题

- 考虑结构体：

```c
 struct node
 {
     int8_t  a;
     int32_t b;
     int16_t c;
 };
```

- 以上结构体，在不同的的平台中，成员的尺寸是固定不变的，但由于不同平台下各个成员的m值可能会发生改变，因此成员之间的相对位置可能是飘忽不定的，这对数据的可移植性提出了挑战。

- 解决的办法有两种：

- 第一，固定每一个成员的m值，也就是每个成员之间的塞入固定大小的填充物固定位置：

```c
 struct node
 {
     int8_t  a __attribute__((aligned(1))); // 将 m 值固定为1
     int64_t b __attribute__((aligned(8))); // 将 m 值固定为8
     int16_t c __attribute__((aligned(2))); // 将 m 值固定为2
 };
```

- 第二，将结构体压实，也就是每个成员之间不留任何空隙：

```c
 struct node
 {
     int8_t  a;
     int64_t b;
     int16_t c;
     int8_t d;
 } __attribute__((packed));
```

# 二、联合体

1. **联合体的基本概念**

- 联合体在外形上跟结构体非常类似，但他们有一个本质的区别：结构体的各个成员是各自独立的，而联合体的各个成员间是共用一块内存，因此联合体也称共用体

![](images/WEBRESOURCEfb6a239bed5b462a85fa7ec4382c92210d7713ba345e0119c37b9a76eb31bf65.png)

- 联合体内部成员共用一块内存形参"堆叠"效果，使得联合体有如下特征

- 联合体变量的尺寸(内存大小)，取决于联合体中尺寸最大的成员

- 联合体的某个成员赋值，会覆盖其他的成员，使它们失效

- 联合体各成员间形成一种"互斥"的逻辑，在某个时刻只有一个成员有效。

- 联合体定义

```c
union  联合体标签    
{
    成员1;
    成员2;
    ...
};
```

- 语法：

- 联合体标签，用于区分各个不同的联合体。

- 成员，是包含在联合体内部的数据，可以是任意的数据类型。

```c
//定义了一个union  attr的联合体类型
union  attr
{
    int a;
    char b;
    double c;
};

int mian(void)
{
    // 定义union  attr类型的联合体变量n
    union  attr n;
}
```

## 联合体操作

- 初始化

```c
     // 普通初始化：第一个成员有效（即只有122有效，其余无效）
    union attr at = {122, 'A', 3.14};

     // 指定成员初始化：最后一个成员有效（即只有3.14有效，其余无效）
    union attr at1 = {.a=122, .b='A', .c=3.14};

    printf("%d\n", at.a);
    printf("%f\n", at1.c);
```

- 成员引用

```c
    union attr n;
    n.a = 233;
    n.b = 'B';
    n.c = 5.23; // 只有最近的一次赋值有效

    printf("%d\n", n.a);
    printf("%c\n", n.b);
    printf("%f\n", n.c);
```

- 联合体指针与数组

```c
    p->a = 110;
    p->b = 'C';// 只有最近的一次赋值有效
    printf("%d\n", p->a);
    printf("%c\n", p->b);
    printf("%f\n", p->c);
    
    
    union attr arr[3] = {[0].a=110,[1].b='a',[2].c=2.13};
    for (int i = 0; i < 3; i++)
    {
        printf("%d\n", arr[i].a);
        printf("%c\n", arr[i].b);
        printf("%f\n", arr[i].c);
    }

```

## 联合体的使用

- 联合体一般很少单独，它经常以一个结构体成员的形式存在，用来表达某种互斥的属性。

```c
struct node
{
    int x;
    char y;
    double z;
    union attr at; // at成员有三种属性，非此即彼    
};
int main(void)
{
    struct node n;
    n.at.a=100;  // 使用连续的成员引用符来索引结构体中的联合体的成员
}
```

## 练习

使用联合体验证当前系统是大端序还是小端序

### 大端序（Big-Endian）

- **特点**：**高位字节存低地址，低位字节存高地址**（类似人类读写数字的习惯，从高位到低位）。

- 示例：0x12345678的存储方式：

| 内存地址 | 存储内容 | 
| -- | -- |
| 0x00 | 0x12（高位） | 
| 0x01 | 0x34 | 
| 0x02 | 0x56 | 
| 0x03 | 0x78（低位） | 


- 常见场景：网络协议（如 TCP/IP）、部分嵌入式系统、PowerPC 架构等。

### **小端序（Little-Endian）**

- **特点**：**低位字节存低地址，高位字节存高地址**（与人类读写习惯相反）。

- 示例：0x12345678的存储方式：

| 内存地址 | 存储内容 | 
| -- | -- |
| 0x00 | 0x78（低位） | 
| 0x01 | 0x56 | 
| 0x02 | 0x34 | 
| 0x03 | 0x12（高位） | 


- 常见场景：x86/x86_64 架构（如 Intel、AMD 处理器）、多数 PC 和服务器系统。

# 三、枚举

- 枚举类型的本质是提供一种范围受限的整型，比如用0-6表示七种颜色，用0-3表示四种状态等，但枚举在C语言中并未实现其本来应有的效果，直到C++环境下枚举才拥有原本该有的属性。

- 枚举常量列表

- enum是关键字

- spectrum是枚举常量列表标签，可以省略。省略的情况下无法定义枚举变量

```c
 enum spectrum{red, orange, yellow=10, green, blue, cyan, purple};
 enum         {reset, running, sleep, stop};
```

- 枚举变量

```
 enum spectrum color = orange; // 等价于 color = 1
```

- 语法要点：

- 枚举常量实质上就是整型，首个枚举常量默认为0。

- 枚举常量在定义时可以赋值，若不赋值，则取其前面的枚举常量的值加1。

- C语言中，枚举等价于整型，支持整型数据的一切操作。

- 使用举例：

```c
 switch(color)
 {
     case red:
         // 处理红色...
     case orange:
         // 处理橙色...
     case yellow:
         // 处理黄色...   
 }
```

- 枚举数据最重要的作用，是使用有意义的单词，来替代无意义的数字，提高程序的可读性。

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 声明枚举 */
// enum color
// {
//     red,   //常量red 代表值 0
//     orange,
//     yellow=9,
//     green,
//     blue=12,
//     purple
// }; 

enum 
{
    red,   //常量red 代表值 0
    orange,
    yellow,
    green=5,
    blue=5,
    purple
}; 

int main(void)
{
    // enum color tmp;
    
    printf("red, %d\n", red);
    printf("green, %d\n", green);
    printf("blue, %d\n", blue);
    printf("purple, %d\n", purple);
    return 0;
}
```

# 晚上作业

[结构体测试题.docx](attachments/WEBRESOURCEc2ef36702a6ecf7e2169723a2d147b08结构体测试题.docx)