1. 结构体与共用体基础概念解析
在C语言编程中，结构体(struct)和共用体(union)是两种非常重要的复合数据类型。它们都允许我们将不同类型的数据组合在一起，但在内存使用方式和应用场景上有着本质区别。
结构体就像是一个"数据收纳盒"，可以同时存放多种类型的数据。每个成员都有自己独立的内存空间，互不干扰。比如我们要描述一个学生信息，可以这样定义：
c复制struct Student {
char name[50]; // 姓名
int age; // 年龄
float score; // 成绩
};
共用体则更像是一个"多功能容器"，所有成员共享同一块内存空间。同一时间只能使用其中一个成员，其他成员的值会被覆盖。这种特性使其在特定场景下非常有用，比如：
c复制union Data {
int i;
float f;
char str[20];
};
提示：结构体适合需要同时保存多个相关数据的场景，而共用体适合需要节省内存或实现类型转换的场景。
2. 结构体的定义与使用详解
2.1 结构体定义语法
结构体的定义遵循特定语法格式：
c复制struct 结构体标签 {
数据类型 成员1;
数据类型 成员2;
// 更多成员...
} 变量列表; // 可选的变量声明
例如定义一个表示日期的结构体：
c复制struct Date {
int year;
int month;
int day;
};
2.2 结构体变量的声明与初始化
声明结构体变量有几种方式：
- 单独声明：
c复制struct Student s1;
- 定义时直接声明变量：
c复制struct Point {
int x;
int y;
} p1, p2;
初始化结构体也有多种方法：
c复制// 完全初始化（按定义顺序）
struct Student s1 = {"张三", 20, 85.5};
// 部分初始化（C99标准支持）
struct Student s2 = {
.name = "李四",
.score = 90.0
};
// 清零初始化
struct Student s3 = {0};
2.3 结构体成员的访问
访问结构体成员使用点运算符(.)：
c复制strcpy(s1.name, "王五");
s1.age = 21;
printf("姓名: %s, 年龄: %d", s1.name, s1.age);
对于结构体指针，使用箭头运算符(->)：
c复制struct Student *ps = &s1;
ps->age = 22;
printf("年龄: %d", ps->age);
注意：字符串类型的成员不能直接用=赋值，必须使用strcpy等字符串函数。
3. 结构体的内存布局与对齐
3.1 字节对齐原理
结构体在内存中的存储遵循对齐原则，这是为了提高CPU访问效率。主要规则包括：
- 每个成员的偏移地址必须是其类型大小的整数倍
- 结构体总大小必须是最大成员大小的整数倍
例如：
c复制struct Example {
char a; // 1字节
int b; // 4字节（偏移必须是4的倍数，所以a后会有3字节填充）
short c; // 2字节
}; // 总大小=1+3+4+2=10，但需要是4的倍数，所以最终为12字节
3.2 计算结构体大小
可以通过sizeof运算符获取结构体大小：
c复制printf("结构体大小: %zu字节\n", sizeof(struct Example));
为了优化内存使用，可以调整成员顺序：
c复制// 优化前：12字节
struct NotOptimized {
char a;
int b;
short c;
};
// 优化后：8字节
struct Optimized {
int b;
short c;
char a;
};
4. 结构体数组与嵌套结构体
4.1 结构体数组
结构体数组允许我们管理多个相同结构的数据：
c复制struct Student class[50];
// 初始化
struct Student class[3] = {
{"张三", 20, 90.5},
{"李四", 21, 85.0},
{"王五", 19, 92.5}
};
// 访问
for (int i = 0; i < 3; i++) {
printf("学生%d: %s, %d岁, 成绩%.1f\n",
i+1, class[i].name, class[i].age, class[i].score);
}
4.2 嵌套结构体
结构体可以包含其他结构体作为成员：
c复制struct Date {
int year;
int month;
int day;
};
struct Student {
char name[50];
struct Date birthday;
float score;
};
// 初始化嵌套结构体
struct Student s = {
"张三",
{2000, 5, 15}, // 生日
90.5
};
// 访问嵌套成员
printf("%s的生日是%d年%d月%d日\n",
s.name, s.birthday.year, s.birthday.month, s.birthday.day);
5. 结构体与函数
5.1 结构体作为函数参数
结构体可以整体作为函数参数传递：
c复制void printStudent(struct Student s) {
printf("姓名: %s\n年龄: %d\n成绩: %.1f\n",
s.name, s.age, s.score);
}
// 调用
printStudent(s1);
但更高效的方式是传递指针：
c复制void modifyStudent(struct Student *ps) {
strcpy(ps->name, "修改后的名字");
ps->age += 1;
}
// 调用
modifyStudent(&s1);
5.2 结构体作为函数返回值
函数可以返回结构体：
c复制struct Student createStudent(const char *name, int age, float score) {
struct Student s;
strcpy(s.name, name);
s.age = age;
s.score = score;
return s;
}
// 调用
struct Student newStudent = createStudent("赵六", 22, 88.5);
提示：返回结构体指针时要小心，不要返回局部变量的地址。
6. 共用体的深入理解
6.1 共用体的定义与特点
共用体的定义语法与结构体类似：
c复制union Data {
int i;
float f;
char str[20];
};
共用体的特点：
- 所有成员共享同一块内存
- 大小由最大成员决定
- 同一时间只能有效存储一个成员的值
6.2 共用体的使用示例
c复制union Data data;
data.i = 10; // 存储整数
printf("%d\n", data.i);
data.f = 3.14; // 存储浮点数，之前的整数值被覆盖
printf("%f\n", data.f);
strcpy(data.str, "Hello"); // 存储字符串，之前的浮点值被覆盖
printf("%s\n", data.str);
6.3 共用体的实际应用
- 类型转换：
c复制union Converter {
float f;
unsigned int i;
} converter;
converter.f = 3.14;
printf("浮点数的二进制表示: %08x\n", converter.i);
- 节省内存：
c复制union Variant {
int intValue;
double doubleValue;
char *stringValue;
};
struct Node {
int type;
union Variant value; // 根据type决定使用哪个成员
};
7. 字节序检测与共用体
7.1 大小端概念
- 大端序(Big Endian)：高位字节存储在低地址
- 小端序(Little Endian)：低位字节存储在高地址
7.2 使用共用体检测字节序
c复制union EndianTest {
int i;
char c[sizeof(int)];
} test;
test.i = 0x12345678;
if (test.c[0] == 0x78) {
printf("小端序\n");
} else {
printf("大端序\n");
}
7.3 指针方式检测字节序
c复制int num = 0x12345678;
char *p = (char *)#
printf("字节序: ");
for (int i = 0; i < sizeof(int); i++) {
printf("%02x ", p[i]);
}
8. 结构体与共用体的综合应用
8.1 协议数据处理
在网络编程中，结构体和共用体常用于解析协议数据：
c复制struct EthernetHeader {
unsigned char dest[6];
unsigned char src[6];
unsigned short type;
};
union IPPacket {
struct {
unsigned char version_ihl;
unsigned char tos;
unsigned short length;
// 更多字段...
} fields;
unsigned char raw[20];
};
8.2 硬件寄存器映射
在嵌入式系统中，用于访问硬件寄存器：
c复制union GPIO_Register {
struct {
unsigned int data : 8;
unsigned int direction : 1;
unsigned int pullup : 1;
unsigned int reserved : 22;
} bits;
unsigned int word;
};
volatile union GPIO_Register *gpio = (union GPIO_Register *)0xFFFF0000;
gpio->bits.direction = 1; // 设置为输出模式
8.3 变体数据类型实现
实现可以存储多种类型的数据结构：
c复制#define TYPE_INT 0
#define TYPE_FLOAT 1
#define TYPE_STRING 2
struct Variant {
int type;
union {
int i;
float f;
char *s;
} value;
};
void printVariant(struct Variant v) {
switch (v.type) {
case TYPE_INT:
printf("%d\n", v.value.i);
break;
case TYPE_FLOAT:
printf("%f\n", v.value.f);
break;
case TYPE_STRING:
printf("%s\n", v.value.s);
break;
}
}
9. 常见问题与调试技巧
9.1 结构体初始化问题
c复制// 错误示例
struct Student s;
s = {"张三", 20, 90.5}; // 编译错误
// 正确做法
struct Student s = {"张三", 20, 90.5}; // 定义时初始化
// 或
struct Student s;
strcpy(s.name, "张三");
s.age = 20;
s.score = 90.5;
9.2 字符串成员处理
c复制// 错误示例
struct Student s;
s.name = "张三"; // 错误，数组名不能作为左值
// 正确做法
strcpy(s.name, "张三"); // 对于字符数组
// 或使用指针成员
struct Student2 {
char *name; // 需要额外管理内存
// ...
};
s.name = strdup("张三"); // 记得最后要free
9.3 字节对齐导致的跨平台问题
c复制// 解决方案1：使用编译器指令
#pragma pack(push, 1) // 1字节对齐
struct PackedData {
char a;
int b;
short c;
};
#pragma pack(pop)
// 解决方案2：手动填充
struct ManualPacked {
char a;
char _padding1[3]; // 手动填充
int b;
short c;
char _padding2[2]; // 手动填充
};
9.4 共用体数据覆盖问题
c复制union Data data;
data.i = 10;
printf("%d\n", data.i); // 正确
data.f = 3.14;
printf("%d\n", data.i); // 错误，i的值已被覆盖
10. 性能优化与最佳实践
10.1 结构体传参优化
c复制// 低效方式（传递整个结构体副本）
void processStudent(struct Student s) { ... }
// 高效方式（传递指针）
void processStudent(const struct Student *ps) { ... }
10.2 结构体成员排序优化
c复制// 优化前（可能有填充）
struct BadLayout {
char a;
int b;
char c;
short d;
}; // 可能占用12字节
// 优化后（减少填充）
struct GoodLayout {
int b;
short d;
char a;
char c;
}; // 可能占用8字节
10.3 共用体的安全使用
c复制// 不安全的使用
union Data data;
data.i = 10;
printf("%f\n", data.f); // 未定义行为
// 安全的使用方式
union Data data;
data.i = 10;
if (current_type == INT_TYPE) {
printf("%d\n", data.i);
}
10.4 使用typedef简化代码
c复制typedef struct {
char name[50];
int age;
} Student; // 现在可以直接用Student代替struct Student
Student s1; // 更简洁
在实际项目中，结构体和共用体的选择应该基于具体需求。结构体适合需要同时保存多个相关数据的场景，而共用体则适合需要节省内存或实现类型转换的场景。理解它们的内存布局和特性，可以帮助我们编写出更高效、更可靠的代码。