一，前言
在我们学习了操作符，选择语句，循环语句，函数以及数组等这些必不可少的知识。那么你是都会好奇，到底学到哪里才算是一个阶段。那我今天就告诉你，C语言结构体学完这个，你就算是把这个初阶的知识学完了。你想的没有错，本篇写完C语言初阶就完结了（后续会更新进阶）。感谢各位大佬的支持，从刚开始写博客没想到会坚持到现在，心情真的很复杂。胡不多说，C语言结构体开讲！！！（本篇50%内容借助ai生成）
一，结构体(struct)
1,结构体的介绍
在C语言中，结构体(struct) 是一种自定义的复合数据类型，允许将多个不同类型的变量组合成一个逻辑单元，类似于现实世界中对象的属性集合。它是C语言实现数据封装和抽象的核心机制之一。
2，结构体定义
在C语言中，结构体也是非常重要的一个部分，想要学好结构体，那么先从定义开始！
struct Student
{char name[50]; //姓名int age; //年龄float score; //分数char gender; //性别
};3.用定义去描述一件事物
假如我想要用结构体描述一本书，我想知道它的价格，多少页，名字是什么？
struct Book
{char BookName[30]; //书的名字double Money; //多少钱int Page; //页数char author //作者
}; //分号不可省略二，实例化结构体变量
1，直接声明
struct Book myBook; // 声明一个book类型的变量2，使用typedef简化
typedef struct
{char title[100];char author[50];int pages;float price;
} Book;
三，结构体中如何访问成员
#include <stdio.h>
#include <string.h>
// 定义书籍结构体
typedef struct {char title[100]; // 书名char author[50]; // 作者int pages; // 页数float price; // 价格
} Book;
// 打印书籍信息函数
void print_book_info(const Book* book) {printf("===== 书籍信息 =====\n""书名：%s\n""作者：%s\n""页数：%d页\n""价格：%.2f元\n",book->title, book->author, book->pages, book->price);
}
int main() {// 直接初始化结构体变量Book myBook = {.title = "结构体指南",.author = "Hou'",.pages = 99,.price = 0.00};print_book_info(&myBook);return 0;
}四， 内存布局与对齐规则
1，结构体内存布局基本特征
| 成员按照声明顺序依次存储 |
| 每个成员的起始地址都必须满足其类型的对其要求 |
| 结构体总大小必须是最大成员对齐值的整数倍 |
2. 内存布局示意图
struct Example
{char a; // 1字节int b; // 4字节short c; // 2字节double d; // 8字节
};内存布局（假设8字节对齐）
| a | 填充3字节 | b (4字节) | c | 填充6字节 | d (8字节) |
| 0 1 2 3 | 4 5 6 7 | 8 9 | 10-15 | 16-23 |3、对齐规则详解
3.1.对齐系数
基本类型对齐值 = 类型大小
char : 1字节
short : 2字节
int : 4字节
double : 8字节
结构体对齐值 = 类型大小2. 偏移量计算规则
注：每个成员的编译地址必须满足：
offset % alignment == 03. 结构体总大小计算
计算累计代下（包含填充字节）
最终大小必须时最大对齐值得整数倍四、内存对齐的本质原因 （仅做了解）
| 硬件优化 | 缓存行优化 | 原子操作支持 |
| CPU访问对齐内存效率更高 | 现在CPU缓存行通常为64字节 | 原子操作必须对齐（看情况） |
| 某些架构无法直接访问非对齐内存 | 对齐数据可以最大化缓存利用率 |
五，结构体的优势
1. 数据封装与逻辑组织
优势：将多个相关数据项组合为单一实体，形成有意义的抽象数据类型。
示例：管理学生信息时，无需使用多个独立变量，而是组合成一个逻辑单元。
// 未使用结构体（松散变量）
char studentName[50];
int studentAge;
float studentGPA;
char studentMajor[30];
// 使用结构体（封装数据）
struct Student
{char name[50];int age;float gpa;char major[30];
};2. 简化函数参数传递
优势：通过传递结构体指针，减少函数参数数量，提升代码可维护性。
// 未使用结构体：需传递多个参数
void printStudent(char *name, int age, float gpa)
{printf("Name: %s, Age: %d, GPA: %.2f\n", name, age, gpa);
}// 使用结构体：只需一个指针参数
void printStudent(struct Student *s){printf("Name: %s, Age: %d, GPA: %.2f\n", s->name, s->age, s->gpa);
}3. 高效内存管理
优势：结构体成员在内存中连续存储，提升缓存利用率，适合批量处理数据。
// 创建结构体数组
struct Student class[50];
// 连续访问内存（高效率）
for (int i = 0; i < 50; i++)
{class[i].age = 18 + i;
}
对比松散变量：
int ages[50];
char names[50][50];
// 内存不连续，缓存命中率低4. 增强代码可读性与维护性
优势：通过有意义的类型命名，使代码自文档化。
// 未使用结构体（含义不明确）
void processData(int x, int y, int width, int height);
// 使用结构体（语义清晰）
struct Rectangle
{int x;int y;int width;int height;
};
void processRect(struct Rectangle *rect);六，结构体高级用法
1. 动态内存分配
typedef struct TreeNode
{int data;struct TreeNode *left;struct TreeNode *right;
} TreeNode;
// 创建树节点
TreeNode* createNode(int val)
{TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));if(newNode)
{newNode->data = val;newNode->left = newNode->right = NULL;}return newNode;
}
// 插入二叉搜索树
void insertBST(TreeNode** root, int val)
{if(!*root)
{*root = createNode(val);return;}if(val < (*root)->data)insertBST(&(*root)->left, val);elseinsertBST(&(*root)->right, val);
}2. 自引用结构体（链表）
struct ListNode
{int val;struct ListNode* next;struct ListNode* random; // 复杂链表
};// 深拷贝带随机指针的链表
struct ListNode* copyRandomList(struct ListNode* head){// ...实现省略...
}3. 实现类面向对象编程
typedef struct
{int x, y;void (*draw)(void* self); // 函数指针void (*move)(void* self, int dx, int dy);
} Shape;// 圆形实现
void circleDraw(void* self){Shape* s = (Shape*)self;printf("Drawing circle at (%d,%d)\n", s->x, s->y);
}void circleMove(void* self, int dx, int dy){Shape* s = (Shape*)self;s->x += dx;s->y += dy;
}// 创建对象
Shape createCircle(int x, int y)
{return (Shape){x, y, circleDraw, circleMove};
}// 使用
Shape c = createCircle(10,20);
c.draw(&c);
c.move(&c,5,5);七，结构体与函数
1. 值传递 vs 指针传递
typedef struct
{int x;int y;
} Point;// 值传递（复制整个结构体）
void movePointVal(Point p, int dx, int dy){p.x += dx;p.y += dy; // 修改不影响原结构体
}// 指针传递（推荐方式）
void movePointPtr(Point* p, int dx, int dy)
{p->x += dx;p->y += dy; // 直接影响原结构体
}int main() {Point pt = {10, 20};movePointVal(pt, 5, 5); // pt仍为(10,20)movePointPtr(&pt, 5, 5); // pt变为(15,25)return 0;
}八，学生管理系统
学生管理系统得实现和功能
1，数据结构：
使用链表结构存储学生数据
学生信息包含：学号、姓名、年龄、成绩
2，主要功能：
添加学生信息（自动检测学号重复）
删除学生信息（按学号）
修改学生信息（按学号）
查询学生（支持学号/姓名查询）
显示所有学生信息（表格形式）
数据持久化（二进制文件存储）
3，特色功能：
输入合法性检测
内存自动管理
友好的用户界面
数据文件自动加载/保存#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>#define MAX_NAME_LEN 50
#define MAX_ID_LEN 15
#define DATA_FILE "students.dat"typedef struct Student
{char id[MAX_ID_LEN]; // 学号char name[MAX_NAME_LEN]; // 姓名int age; // 年龄float score; // 成绩struct Student *next; // 链表指针
} Student;Student *head = NULL; // 全局链表头指针/* 函数声明 */
void display_menu();
void add_student();
void delete_student();
void modify_student();
void search_student();
void display_all();
void save_to_file();
void load_from_file();
void clear_list();
int is_id_exist(const char *id);
Student *create_node();
void press_enter_to_continue();int main() {load_from_file();int choice;do {display_menu();printf("请输入选项：");scanf("%d", &choice);while(getchar() != '\n'); // 清空输入缓冲区switch(choice){case 1: add_student(); break;case 2: delete_student(); break;case 3: modify_student(); break;case 4: search_student(); break;case 5: display_all(); break;case 6: save_to_file(); break;case 0: printf("感谢使用！\n"); break;default: printf("无效选项，请重新输入！\n");}} while(choice != 0);clear_list();return 0;
}void display_menu()
{printf("\n===== 学生管理系统 =====\n");printf("1. 添加学生\n");printf("2. 删除学生\n");printf("3. 修改信息\n");printf("4. 查询学生\n");printf("5. 显示所有学生\n");printf("6. 保存数据\n");printf("0. 退出系统\n");printf("=========================\n");
}Student *create_node()
{Student *new_node = (Student *)malloc(sizeof(Student));if(new_node == NULL)
{printf("内存分配失败！\n");exit(EXIT_FAILURE);}new_node->next = NULL;return new_node;
}void add_student()
{Student *new_node = create_node();printf("\n--- 添加学生 ---\n");do {printf("请输入学号：");fgets(new_node->id, MAX_ID_LEN, stdin);new_node->id[strcspn(new_node->id, "\n")] = '\0'; // 去除换行符} while(is_id_exist(new_node->id));printf("请输入姓名：");fgets(new_node->name, MAX_NAME_LEN, stdin);new_node->name[strcspn(new_node->name, "\n")] = '\0';printf("请输入年龄：");scanf("%d", &new_node->age);printf("请输入成绩：");scanf("%f", &new_node->age);// 头插法添加到链表new_node->next = head;head = new_node;printf("添加成功！\n");press_enter_to_continue();
}void delete_student(){if(head == NULL){printf("当前没有学生记录！\n");return;}char target_id[MAX_ID_LEN];printf("\n--- 删除学生 ---\n");printf("请输入要删除的学号：");fgets(target_id, MAX_ID_LEN, stdin);target_id[strcspn(target_id, "\n")] = '\0';Student *current = head, *prev = NULL;while(current != NULL)
{if(strcmp(current->id, target_id) == 0)
{if(prev == NULL){head = current->next;} else
{prev->next = current->next;}free(current);printf("删除成功！\n");press_enter_to_continue();return;}prev = current;current = current->next;}printf("未找到该学号的学生！\n");press_enter_to_continue();
}void modify_student()
{if(head == NULL)
{printf("当前没有学生记录！\n");return;}char target_id[MAX_ID_LEN];printf("\n--- 修改信息 ---\n");printf("请输入要修改的学号：");fgets(target_id, MAX_ID_LEN, stdin);target_id[strcspn(target_id, "\n")] = '\0';Student *current = head;while(current != NULL)
{if(strcmp(current->id, target_id) == 0) {printf("原姓名：%s\n新姓名：", current->name);fgets(current->name, MAX_NAME_LEN, stdin);current->name[strcspn(current->name, "\n")] = '\0';printf("原年龄：%d\n新年龄：", current->age);scanf("%d", ¤t->age);printf("原成绩：%.1f\n新成绩：", current->score);scanf("%f", ¤t->score);printf("修改成功！\n");press_enter_to_continue();return;}current = current->next;}printf("未找到该学号的学生！\n");press_enter_to_continue();
}void search_student()
{if(head == NULL)
{printf("当前没有学生记录！\n");return;}char target[MAX_ID_LEN];printf("\n--- 查询学生 ---\n");printf("请输入学号或姓名：");fgets(target, MAX_ID_LEN, stdin);target[strcspn(target, "\n")] = '\0';Student *current = head;int found = 0;while(current != NULL)
{if(strcmp(current->id, target) == 0 || strcmp(current->name, target) == 0)
{printf("\n学号：%s\n", current->id);printf("姓名：%s\n", current->name);printf("年龄：%d\n", current->age);printf("成绩：%.1f\n\n", current->score);found = 1;}current = current->next;}if(!found)
{printf("未找到匹配的学生！\n");}press_enter_to_continue();
}void display_all()
{if(head == NULL)
{printf("当前没有学生记录！\n");return;}printf("\n%-15s%-20s%-8s%-8s\n", "学号", "姓名", "年龄", "成绩");printf("----------------------------------------\n");Student *current = head;while(current != NULL){printf("%-15s%-20s%-8d%-8.1f\n", current->id, current->name,current->age,current->score);current = current->next;}press_enter_to_continue();
}void save_to_file(){FILE *fp = fopen(DATA_FILE, "wb");if(fp == NULL)
{printf("无法打开文件进行保存！\n");return;}Student *current = head;while(current != NULL)
{fwrite(current, sizeof(Student), 1, fp);current = current->next;}fclose(fp);printf("数据已保存到%s\n", DATA_FILE);press_enter_to_continue();
}void load_from_file(){FILE *fp = fopen(DATA_FILE, "rb");if(fp == NULL) return;Student temp, *new_node;while(fread(&temp, sizeof(Student), 1, fp) == 1){new_node = create_node();memcpy(new_node, &temp, sizeof(Student));new_node->next = head;head = new_node;}fclose(fp);
}void clear_list()
{Student *current = head;while(current != NULL)
{Student *temp = current;current = current->next;free(temp);}head = NULL;
}int is_id_exist(const char *id){Student *current = head;while(current != NULL)
{if(strcmp(current->id, id) == 0)
{printf("该学号已存在！\n");return 1;}current = current->next;}return 0;
}void press_enter_to_continue(){printf("\n按回车键继续...");while(getchar() != '\n');getchar(); // 等待回车
}十，结构体
以下是一份系统完整的C语言结构体综合示例代码，涵盖结构体核心用法、内存管理、高级特性及实际应用
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h> // 用于offsetof宏
/*-----------------------------------------第一部分：结构体基础与内存布局
-----------------------------------------*/
// 基础结构体定义
typedef struct
{char id[10];int age;double score;
} Student;
// 带内存对齐控制的结构体
#pragma pack(push, 1) // 1字节对齐
typedef struct
{char type;int code;short flag;
} PackedData;
#pragma pack(pop) // 恢复默认对齐
void basic_demo(){printf("\n=== 结构体基础与内存布局演示 ===\n");Student s1 = {"A1001", 20, 85.5};printf("学生 %s 年龄：%d 分数：%.1f\n", s1.id, s1.age, s1.score);printf("默认对齐结构体大小：%zu\n", sizeof(Student));printf("紧凑对齐结构体大小：%zu\n", sizeof(PackedData));
}/*-----------------------------------------第二部分：结构体高级特性
-----------------------------------------*/
// 位域结构体
typedef struct
{unsigned int is_active : 1;unsigned int mode : 3;unsigned int : 4; // 未命名位域unsigned int value : 8;
} StatusRegister;// 包含函数指针的结构体
typedef struct
{double x, y;void (*print)(const struct Vector*);
} Vector;void vector_print(const Vector* v)
{printf("(%.2f, %.2f)\n", v->x, v->y);
}// 柔性数组成员
typedef struct
{size_t length;int data[];
} IntArray;IntArray* create_int_array(size_t len)
{IntArray* arr = malloc(sizeof(IntArray) + len * sizeof(int));if(arr)
{arr->length = len;for(size_t i=0; i<len; i++) arr->data[i] = (int)(i+1);}return arr;
}void advanced_demo(){printf("\n=== 高级特性演示 ===\n");// 位域操作StatusRegister reg = {1, 5, 128};printf("状态寄存器：active=%d mode=%d value=%d\n", reg.is_active, reg.mode, reg.value);// 函数指针成员Vector v = {3.5, 4.2, vector_print};printf("向量坐标：");v.print(&v);// 柔性数组使用IntArray* arr = create_int_array(5);printf("动态数组：");for(size_t i=0; i<arr->length; i++)printf("%d ", arr->data[i]);free(arr);
}/*-----------------------------------------第三部分：结构体与函数
-----------------------------------------*/
// 结构体作为函数参数
void update_student(Student* s, int new_age)
{s->age = new_age;s->score *= 1.1;
}// 返回结构体的函数
Student create_student(const char* id, int age)
{Student s;strncpy(s.id, id, sizeof(s.id)-1);s.age = age;s.score = 60.0;return s;
}// 回调函数示例
typedef struct
{int value;void (*callback)(int);
} Event;void event_handler(int val)
{printf("事件触发，值：%d\n", val);
}void function_demo() {printf("\n=== 结构体与函数交互演示 ===\n");Student s2 = create_student("B2002", 19);update_student(&s2, 20);printf("更新后学生：%s 年龄：%d\n", s2.id, s2.age);Event e = {100, event_handler};if(e.callback) e.callback(e.value);
}/*-----------------------------------------第四部分：链表数据结构实现
-----------------------------------------*/
typedef struct Node {int data;struct Node* next;
} ListNode;ListNode* create_list(int values[], int n) {ListNode head = {0, NULL};ListNode* current = &head;for(int i=0; i<n; i++) {current->next = malloc(sizeof(ListNode));current = current->next;current->data = values[i];current->next = NULL;}return head.next;
}void list_demo()
{printf("\n=== 链表结构演示 ===\n");int values[] = {10, 20, 30, 40};ListNode* list = create_list(values, 4);ListNode* current = list;while(current){printf("%d -> ", current->data);current = current->next;}printf("NULL\n");// 内存释放（实际开发需实现）
}/*-----------------------------------------第五部分：内存对齐验证
-----------------------------------------*/
void alignment_check()
{printf("\n=== 内存对齐验证 ===\n");printf("Student结构体成员偏移：\n");printf("id偏移：%zu\n", offsetof(Student, id));printf("age偏移：%zu\n", offsetof(Student, age));printf("score偏移：%zu\n", offsetof(Student, score));// 静态断言（C11）_Static_assert(sizeof(Student) == 24, "Student结构体大小异常");
}int main(){basic_demo();advanced_demo();function_demo();list_demo();alignment_check();return 0;
}
