当前位置：首页 > news >正文

C语言结构体与内存分配：构建复杂数据结构的基石

news 2025/8/13 9:10:35

当面对复杂的实际问题时，基本类型往往无法满足需求。结构体(struct)作为C语言中最重要的复合数据类型，为我们提供了组织和管理复杂数据的强大工具。本文将深入探讨结构体的定义、使用以及相关的高级特性。

文章目录

1、结构体基础：数据的有机组合
- 结构体的定义与声明
- 结构体的初始化与成员访问
- 结构体的嵌套定义
2、结构体数组：批量数据管理
- 结构体数组的定义与使用
- 结构体数组的高级操作
3、结构体指针：高效的数据访问
- 指针访问结构体成员
- 结构体数组指针的应用
4、结构体与函数：模块化编程
- 结构体作为函数参数
- 函数返回结构体
5、动态内存分配：灵活的数据管理
- malloc与结构体
- 链表实现：结构体的高级应用
6、共用体与位段：内存的精确控制
- 共用体(Union)的使用
- 位段(Bit Fields)的应用
7、总结

1、结构体基础：数据的有机组合

结构体的定义与声明

结构体允许我们将不同类型的数据组合成一个逻辑单元：

#include <stdio.h>
#include <string.h>// 基本结构体定义
struct Student {long int id;           // 学号char name[50];         // 姓名char gender;           // 性别int age;              // 年龄float score;          // 成绩
};// 定义的同时声明变量
struct Book {char title[100];char author[50];char isbn[20];float price;int pages;
} book1, book2;           // 同时定义两个变量// 匿名结构体（省略结构体名）
struct {int x, y;
} point1, point2;int main() {// 结构体变量的定义方式struct Student stu1;                    // 先定义类型，再定义变量struct Student stu2, stu3;              // 一次定义多个变量printf("结构体定义成功\n");return 0;
}

结构体的初始化与成员访问

#include <stdio.h>
#include <string.h>struct Employee {int id;char name[30];char department[20];float salary;
};int main() {// 初始化方法1：定义时初始化struct Employee emp1 = {1001, "张三", "技术部", 8500.0};// 初始化方法2：指定成员初始化（C99标准）struct Employee emp2 = {.id = 1002,.name = "李四",.department = "销售部",.salary = 7200.0};// 初始化方法3：部分初始化struct Employee emp3 = {1003, "王五"};  // 其余成员自动初始化为0// 成员访问和赋值emp3.salary = 9000.0;strcpy(emp3.department, "管理部");// 输出员工信息printf("员工信息:\n");printf("ID: %d, 姓名: %s, 部门: %s, 薪资: %.1f\n", emp1.id, emp1.name, emp1.department, emp1.salary);printf("ID: %d, 姓名: %s, 部门: %s, 薪资: %.1f\n", emp2.id, emp2.name, emp2.department, emp2.salary);printf("ID: %d, 姓名: %s, 部门: %s, 薪资: %.1f\n", emp3.id, emp3.name, emp3.department, emp3.salary);return 0;
}

结构体的嵌套定义

结构体可以包含其他结构体作为成员，实现复杂的数据组织：

#include <stdio.h>
#include <string.h>// 日期结构体
struct Date {int year;int month;int day;
};// 地址结构体
struct Address {char street[100];char city[50];char province[50];char postal_code[10];
};// 学生结构体，包含嵌套结构
struct Student {long int id;char name[50];char gender;struct Date birthday;      // 嵌套日期结构体struct Address address;    // 嵌套地址结构体struct Student *next;      // 自引用指针（用于链表）
};int main() {struct Student stu = {.id = 20230001,.name = "陈小明",.gender = 'M',.birthday = {2005, 3, 15},.address = {"中山路123号","广州市","广东省","510000"},.next = NULL};// 访问嵌套结构体成员printf("学生信息:\n");printf("学号: %ld\n", stu.id);printf("姓名: %s\n", stu.name);printf("性别: %c\n", stu.gender);printf("生日: %d年%d月%d日\n", stu.birthday.year, stu.birthday.month, stu.birthday.day);printf("地址: %s省%s%s %s\n", stu.address.province, stu.address.city, stu.address.street, stu.address.postal_code);return 0;
}

2、结构体数组：批量数据管理

结构体数组的定义与使用

#include <stdio.h>
#include <string.h>struct Product {int id;char name[30];float price;int stock;
};int main() {// 定义并初始化结构体数组struct Product products[4] = {{1001, "笔记本电脑", 5999.0, 10},{1002, "智能手机", 3299.0, 25},{1003, "平板电脑", 2199.0, 15},{1004, "智能手表", 1599.0, 30}};printf("商品库存清单:\n");printf("%-6s %-12s %8s %6s\n", "编号", "商品名称", "价格", "库存");printf("----------------------------------------\n");// 遍历结构体数组for (int i = 0; i < 4; i++) {printf("%-6d %-12s %8.1f %6d\n", products[i].id, products[i].name, products[i].price, products[i].stock);}// 计算总价值float total_value = 0;for (int i = 0; i < 4; i++) {total_value += products[i].price * products[i].stock;}printf("----------------------------------------\n");printf("库存总价值: %.2f 元\n", total_value);// 查找特定商品int search_id = 1002;for (int i = 0; i < 4; i++) {if (products[i].id == search_id) {printf("找到商品: %s, 价格: %.1f\n", products[i].name, products[i].price);break;}}return 0;
}

结构体数组的高级操作

#include <stdio.h>
#include <string.h>
#include <stdlib.h>struct Score {char subject[20];float score;
};struct Student {int id;char name[30];struct Score scores[3];  // 嵌套结构体数组float average;
};// 计算平均分
void calculate_average(struct Student *stu) {float sum = 0;for (int i = 0; i < 3; i++) {sum += stu->scores[i].score;}stu->average = sum / 3.0;
}// 按平均分排序（冒泡排序）
void sort_students(struct Student students[], int count) {for (int i = 0; i < count - 1; i++) {for (int j = 0; j < count - i - 1; j++) {if (students[j].average < students[j + 1].average) {struct Student temp = students[j];students[j] = students[j + 1];students[j + 1] = temp;}}}
}int main() {struct Student students[3] = {{1001, "张三", {{"数学", 85}, {"英语", 78}, {"物理", 92}}, 0},{1002, "李四", {{"数学", 92}, {"英语", 88}, {"物理", 85}}, 0},{1003, "王五", {{"数学", 78}, {"英语", 95}, {"物理", 89}}, 0}};// 计算每个学生的平均分for (int i = 0; i < 3; i++) {calculate_average(&students[i]);}printf("排序前学生成绩:\n");for (int i = 0; i < 3; i++) {printf("学号: %d, 姓名: %s, 平均分: %.1f\n", students[i].id, students[i].name, students[i].average);}// 按平均分排序sort_students(students, 3);printf("\n按平均分排序后:\n");for (int i = 0; i < 3; i++) {printf("第%d名: %s (%.1f分)\n", i + 1, students[i].name, students[i].average);printf("  各科成绩: ");for (int j = 0; j < 3; j++) {printf("%s:%.0f ", students[i].scores[j].subject, students[i].scores[j].score);}printf("\n");}return 0;
}

3、结构体指针：高效的数据访问

指针访问结构体成员

#include <stdio.h>
#include <string.h>struct Rectangle {float width;float height;float area;
};// 计算矩形面积
void calculate_area(struct Rectangle *rect) {rect->area = rect->width * rect->height;
}// 打印矩形信息
void print_rectangle(struct Rectangle *rect) {printf("矩形信息: 宽度=%.1f, 高度=%.1f, 面积=%.1f\n", rect->width, rect->height, rect->area);
}int main() {struct Rectangle rect1 = {10.5, 8.0, 0};struct Rectangle rect2 = {6.5, 4.5, 0};// 使用指针访问结构体struct Rectangle *p1 = &rect1;struct Rectangle *p2 = &rect2;// 三种访问方式的等价性printf("三种访问方式演示:\n");printf("rect1.width = %.1f\n", rect1.width);          // 直接访问printf("(*p1).width = %.1f\n", (*p1).width);          // 指针解引用printf("p1->width = %.1f\n", p1->width);               // 箭头操作符// 使用函数处理结构体calculate_area(p1);calculate_area(p2);print_rectangle(p1);print_rectangle(p2);// 指针数组struct Rectangle *rects[] = {&rect1, &rect2};printf("\n通过指针数组访问:\n");for (int i = 0; i < 2; i++) {printf("矩形%d面积: %.1f\n", i + 1, rects[i]->area);}return 0;
}

结构体数组指针的应用

#include <stdio.h>
#include <string.h>struct Employee {int id;char name[30];float salary;int department_id;
};// 使用指针遍历结构体数组
void print_employees(struct Employee *emps, int count) {struct Employee *p = emps;  // 指向数组首元素printf("员工列表:\n");printf("%-6s %-10s %8s %6s\n", "ID", "姓名", "薪资", "部门");printf("--------------------------------\n");for (int i = 0; i < count; i++) {printf("%-6d %-10s %8.0f %6d\n", p->id, p->name, p->salary, p->department_id);p++;  // 指针算术运算，移动到下一个元素}
}// 查找薪资最高的员工
struct Employee* find_highest_salary(struct Employee *emps, int count) {struct Employee *highest = emps;struct Employee *current = emps;for (int i = 1; i < count; i++) {current++;if (current->salary > highest->salary) {highest = current;}}return highest;
}int main() {struct Employee employees[] = {{1001, "张三", 8500, 1},{1002, "李四", 7200, 2},{1003, "王五", 9200, 1},{1004, "赵六", 6800, 3},{1005, "陈七", 8800, 2}};int emp_count = sizeof(employees) / sizeof(employees[0]);print_employees(employees, emp_count);struct Employee *highest = find_highest_salary(employees, emp_count);printf("\n薪资最高员工: %s (%.0f元)\n", highest->name, highest->salary);return 0;
}

4、结构体与函数：模块化编程

结构体作为函数参数

#include <stdio.h>
#include <math.h>struct Point {double x, y;
};struct Circle {struct Point center;double radius;
};// 值传递：传递结构体副本
double calculate_distance_value(struct Point p1, struct Point p2) {double dx = p1.x - p2.x;double dy = p1.y - p2.y;return sqrt(dx * dx + dy * dy);
}// 地址传递：传递结构体指针（推荐）
double calculate_distance_pointer(struct Point *p1, struct Point *p2) {double dx = p1->x - p2->x;double dy = p1->y - p2->y;return sqrt(dx * dx + dy * dy);
}// 计算圆的面积
double calculate_circle_area(struct Circle *circle) {const double PI = 3.14159;return PI * circle->radius * circle->radius;
}// 移动圆的位置
void move_circle(struct Circle *circle, double dx, double dy) {circle->center.x += dx;circle->center.y += dy;
}int main() {struct Point p1 = {0, 0};struct Point p2 = {3, 4};// 比较两种传参方式printf("两点距离 (值传递): %.2f\n", calculate_distance_value(p1, p2));printf("两点距离 (指针传递): %.2f\n", calculate_distance_pointer(&p1, &p2));// 圆的操作struct Circle circle = {{5.0, 5.0}, 3.0};printf("\n原始圆心位置: (%.1f, %.1f)\n", circle.center.x, circle.center.y);printf("圆的面积: %.2f\n", calculate_circle_area(&circle));move_circle(&circle, 2.0, -1.5);printf("移动后圆心位置: (%.1f, %.1f)\n", circle.center.x, circle.center.y);return 0;
}

函数返回结构体

#include <stdio.h>
#include <string.h>struct Student {int id;char name[30];float score;
};// 创建学生信息
struct Student create_student(int id, const char *name, float score) {struct Student stu;stu.id = id;strcpy(stu.name, name);stu.score = score;return stu;
}// 查找最高分学生
struct Student find_top_student(struct Student students[], int count) {struct Student top = students[0];for (int i = 1; i < count; i++) {if (students[i].score > top.score) {top = students[i];}}return top;
}// 计算班级统计信息
struct {float average;float highest;float lowest;int pass_count;
} calculate_class_stats(struct Student students[], int count) {struct {float average;float highest;float lowest;int pass_count;} stats = {0, 0, 100, 0};  // 匿名结构体作为返回值float sum = 0;stats.highest = students[0].score;stats.lowest = students[0].score;for (int i = 0; i < count; i++) {sum += students[i].score;if (students[i].score > stats.highest) {stats.highest = students[i].score;}if (students[i].score < stats.lowest) {stats.lowest = students[i].score;}if (students[i].score >= 60) {stats.pass_count++;}}stats.average = sum / count;return stats;
}int main() {// 使用函数创建学生struct Student class[4];class[0] = create_student(1001, "张三", 85.5);class[1] = create_student(1002, "李四", 92.0);class[2] = create_student(1003, "王五", 78.5);class[3] = create_student(1004, "赵六", 88.0);// 显示所有学生printf("班级学生成绩:\n");for (int i = 0; i < 4; i++) {printf("%d. %s: %.1f分\n", class[i].id, class[i].name, class[i].score);}// 查找最高分学生struct Student top = find_top_student(class, 4);printf("\n最高分学生: %s (%.1f分)\n", top.name, top.score);// 计算统计信息auto stats = calculate_class_stats(class, 4);printf("\n班级统计:\n");printf("平均分: %.1f\n", stats.average);printf("最高分: %.1f\n", stats.highest);printf("最低分: %.1f\n", stats.lowest);printf("及格人数: %d/%d\n", stats.pass_count, 4);return 0;
}

5、动态内存分配：灵活的数据管理

malloc与结构体

#include <stdio.h>
#include <stdlib.h>
#include <string.h>struct Book {char title[100];char author[50];float price;int pages;
};// 创建动态书籍数组
struct Book* create_book_array(int count) {struct Book *books = (struct Book*)malloc(count * sizeof(struct Book));if (books == NULL) {printf("内存分配失败!\n");return NULL;}return books;
}// 初始化书籍信息
void init_book(struct Book *book, const char *title, const char *author, float price, int pages) {strcpy(book->title, title);strcpy(book->author, author);book->price = price;book->pages = pages;
}// 打印书籍信息
void print_books(struct Book *books, int count) {printf("图书信息:\n");printf("%-25s %-15s %8s %6s\n", "书名", "作者", "价格", "页数");printf("--------------------------------------------------------\n");for (int i = 0; i < count; i++) {printf("%-25s %-15s %8.1f %6d\n", books[i].title, books[i].author, books[i].price, books[i].pages);}
}// 释放内存并演示realloc
struct Book* expand_book_array(struct Book *books, int old_count, int new_count) {struct Book *new_books = (struct Book*)realloc(books, new_count * sizeof(struct Book));if (new_books == NULL) {printf("内存重新分配失败!\n");return books;  // 返回原指针}printf("数组已从 %d 本书扩展到 %d 本书\n", old_count, new_count);return new_books;
}int main() {int initial_count = 3;// 动态分配内存struct Book *library = create_book_array(initial_count);if (library == NULL) {return 1;}// 初始化书籍init_book(&library[0], "C程序设计", "谭浩强", 39.0, 320);init_book(&library[1], "数据结构", "严蔚敏", 45.0, 380);init_book(&library[2], "计算机组成原理", "白中英", 52.0, 420);print_books(library, initial_count);// 扩展数组int new_count = 5;library = expand_book_array(library, initial_count, new_count);// 添加新书init_book(&library[3], "操作系统", "汤小丹", 48.0, 360);init_book(&library[4], "计算机网络", "谢希仁", 42.0, 340);printf("\n扩展后的图书馆:\n");print_books(library, new_count);// 使用calloc分配并初始化为0的内存struct Book *zero_books = (struct Book*)calloc(2, sizeof(struct Book));if (zero_books) {printf("\n使用calloc分配的内存已初始化为0:\n");printf("书名为空: '%s'\n", zero_books[0].title);printf("价格为0: %.1f\n", zero_books[0].price);free(zero_books);}// 释放内存free(library);printf("\n内存已释放\n");return 0;
}

链表实现：结构体的高级应用

#include <stdio.h>
#include <stdlib.h>
#include <string.h>struct ListNode {int id;char name[30];float salary;struct ListNode *next;
};// 创建新节点
struct ListNode* create_node(int id, const char *name, float salary) {struct ListNode *new_node = (struct ListNode*)malloc(sizeof(struct ListNode));if (new_node == NULL) {printf("内存分配失败!\n");return NULL;}new_node->id = id;strcpy(new_node->name, name);new_node->salary = salary;new_node->next = NULL;return new_node;
}// 头插法添加节点
struct ListNode* insert_at_head(struct ListNode *head, int id, const char *name, float salary) {struct ListNode *new_node = create_node(id, name, salary);if (new_node == NULL) return head;new_node->next = head;return new_node;  // 返回新的头节点
}// 尾插法添加节点
struct ListNode* insert_at_tail(struct ListNode *head, int id, const char *name, float salary) {struct ListNode *new_node = create_node(id, name, salary);if (new_node == NULL) return head;if (head == NULL) {return new_node;  // 空链表，新节点成为头节点}// 找到尾节点struct ListNode *current = head;while (current->next != NULL) {current = current->next;}current->next = new_node;return head;
}// 遍历链表
void print_list(struct ListNode *head) {printf("员工链表:\n");printf("%-6s %-10s %8s\n", "ID", "姓名", "薪资");printf("------------------------\n");struct ListNode *current = head;while (current != NULL) {printf("%-6d %-10s %8.0f\n", current->id, current->name, current->salary);current = current->next;}printf("\n");
}// 查找节点
struct ListNode* find_node(struct ListNode *head, int id) {struct ListNode *current = head;while (current != NULL) {if (current->id == id) {return current;}current = current->next;}return NULL;
}// 删除节点
struct ListNode* delete_node(struct ListNode *head, int id) {if (head == NULL) return NULL;// 删除头节点if (head->id == id) {struct ListNode *temp = head;head = head->next;free(temp);printf("已删除员工 ID: %d\n", id);return head;}// 删除其他节点struct ListNode *current = head;while (current->next != NULL) {if (current->next->id == id) {struct ListNode *temp = current->next;current->next = temp->next;free(temp);printf("已删除员工 ID: %d\n", id);return head;}current = current->next;}printf("未找到员工 ID: %d\n", id);return head;
}// 释放整个链表
void free_list(struct ListNode *head) {struct ListNode *current = head;while (current != NULL) {struct ListNode *temp = current;current = current->next;free(temp);}printf("链表内存已释放\n");
}int main() {struct ListNode *head = NULL;// 使用尾插法建立链表printf("建立员工链表:\n");head = insert_at_tail(head, 1001, "张三", 8500);head = insert_at_tail(head, 1002, "李四", 7200);head = insert_at_tail(head, 1003, "王五", 9200);print_list(head);// 使用头插法添加新员工printf("添加新员工 (头插法):\n");head = insert_at_head(head, 1000, "赵六", 8800);print_list(head);// 查找员工int search_id = 1002;struct ListNode *found = find_node(head, search_id);if (found) {printf("找到员工: ID=%d, 姓名=%s, 薪资=%.0f\n\n", found->id, found->name, found->salary);}// 删除员工head = delete_node(head, 1002);print_list(head);// 释放链表内存free_list(head);return 0;
}

6、共用体与位段：内存的精确控制

共用体(Union)的使用

共用体允许在同一内存位置存储不同类型的数据：

#include <stdio.h>
#include <string.h>// 基本共用体定义
union Data {int integer;float floating;char string[20];
};// 带标记的共用体（常用模式）
struct TaggedUnion {enum {TYPE_INT, TYPE_FLOAT, TYPE_STRING} type;union Data data;
};// 网络数据包示例
union NetworkPacket {struct {char header[8];char payload[1024];} raw;struct {int packet_id;int length;char data[1024];} structured;
};void print_union_info(union Data *data) {printf("共用体内存地址:\n");printf("整数成员地址: %p\n", &data->integer);printf("浮点成员地址: %p\n", &data->floating);printf("字符串成员地址: %p\n", data->string);printf("共用体大小: %lu 字节\n\n", sizeof(union Data));
}int main() {union Data data;struct TaggedUnion tagged_data;print_union_info(&data);// 存储整数data.integer = 42;printf("存储整数 42:\n");printf("作为整数读取: %d\n", data.integer);printf("作为浮点读取: %f\n", data.floating);  // 未定义行为printf("作为字符串读取: %s\n\n", data.string);  // 未定义行为// 存储浮点数data.floating = 3.14f;printf("存储浮点数 3.14:\n");printf("作为浮点读取: %.2f\n", data.floating);printf("作为整数读取: %d\n\n", data.integer);  // 未定义行为// 存储字符串strcpy(data.string, "Hello");printf("存储字符串 \"Hello\":\n");printf("作为字符串读取: %s\n", data.string);printf("作为整数读取: %d\n\n", data.integer);  // 未定义行为// 使用带标记的共用体（推荐方式）printf("带标记的共用体使用:\n");tagged_data.type = TYPE_INT;tagged_data.data.integer = 100;switch (tagged_data.type) {case TYPE_INT:printf("整数值: %d\n", tagged_data.data.integer);break;case TYPE_FLOAT:printf("浮点值: %.2f\n", tagged_data.data.floating);break;case TYPE_STRING:printf("字符串值: %s\n", tagged_data.data.string);break;}return 0;
}

位段(Bit Fields)的应用

位段允许以位为单位定义结构体成员：

#include <stdio.h>// 基本位段定义
struct Flags {unsigned int flag1 : 1;  // 1位unsigned int flag2 : 1;  // 1位unsigned int flag3 : 1;  // 1位unsigned int reserved : 5; // 5位预留
};// 日期压缩存储
struct CompactDate {unsigned int year : 12;   // 年份 (0-4095)unsigned int month : 4;   // 月份 (0-15)unsigned int day : 5;     // 日期 (0-31)unsigned int : 0;         // 无名位段，强制对齐
};// 网络协议头部
struct IPHeader {unsigned int version : 4;        // IP版本unsigned int header_length : 4;  // 头部长度unsigned int type_of_service : 8; // 服务类型unsigned int total_length : 16;  // 总长度
};// 文件权限
struct FilePermissions {unsigned int owner_read : 1;unsigned int owner_write : 1;unsigned int owner_execute : 1;unsigned int group_read : 1;unsigned int group_write : 1;unsigned int group_execute : 1;unsigned int other_read : 1;unsigned int other_write : 1;unsigned int other_execute : 1;unsigned int : 7;  // 填充到16位
};void print_flags(struct Flags *flags) {printf("标志状态: flag1=%d, flag2=%d, flag3=%d\n",flags->flag1, flags->flag2, flags->flag3);
}void print_date(struct CompactDate *date) {printf("压缩日期: %04d-%02d-%02d\n",date->year, date->month, date->day);
}void print_permissions(struct FilePermissions *perm) {printf("文件权限: ");printf("%c%c%c",perm->owner_read ? 'r' : '-',perm->owner_write ? 'w' : '-',perm->owner_execute ? 'x' : '-');printf("%c%c%c",perm->group_read ? 'r' : '-',perm->group_write ? 'w' : '-',perm->group_execute ? 'x' : '-');printf("%c%c%c\n",perm->other_read ? 'r' : '-',perm->other_write ? 'w' : '-',perm->other_execute ? 'x' : '-');
}int main() {// 标志位操作struct Flags flags = {0};printf("初始化后标志状态:\n");print_flags(&flags);flags.flag1 = 1;flags.flag3 = 1;printf("设置flag1和flag3后:\n");print_flags(&flags);printf("Flags结构体大小: %lu 字节\n\n", sizeof(struct Flags));// 压缩日期struct CompactDate date = {2023, 12, 25};print_date(&date);printf("CompactDate结构体大小: %lu 字节\n", sizeof(struct CompactDate));printf("相比普通日期结构(12字节)节省了空间\n\n");// 文件权限示例 (rwxr-xr--)struct FilePermissions perm = {0};perm.owner_read = 1;perm.owner_write = 1;perm.owner_execute = 1;perm.group_read = 1;perm.group_execute = 1;perm.other_read = 1;print_permissions(&perm);// IP头部示例struct IPHeader ip = {4, 5, 0, 1500};printf("\nIP头部信息:\n");printf("版本: %d, 头部长度: %d, 服务类型: %d, 总长度: %d\n",ip.version, ip.header_length, ip.type_of_service, ip.total_length);printf("IPHeader结构体大小: %lu 字节\n", sizeof(struct IPHeader));return 0;
}