C语言指针高级应用：指向结构体的指针
结构体与指针的基础回顾
在深入探讨指向结构体的指针之前，先简要回顾一下结构体和指针的基本概念。
结构体是一种用户自定义的数据类型，它允许将不同类型的数据组合在一起形成一个单一的实体。例如，我们要描述一个学生，可以定义如下结构体：
struct Student {
char name[20];
int age;
float score;
};
这里定义了一个 struct Student 结构体，它包含了一个字符数组 name 用于存储学生姓名，一个整数 age 表示年龄，以及一个浮点数 score 表示成绩。
指针是一种变量，它存储的是另一个变量的内存地址。例如：
int num = 10;
int *ptr = #
这里 ptr 是一个指向 int 类型变量 num 的指针，通过 & 运算符获取 num 的地址并赋值给 ptr。
指向结构体的指针定义
定义一个指向结构体的指针和定义指向其他类型的指针类似。以刚才定义的 struct Student 结构体为例：
struct Student {
char name[20];
int age;
float score;
};
struct Student *stuPtr;
这里 stuPtr 就是一个指向 struct Student 类型结构体变量的指针。需要注意的是，此时 stuPtr 并没有指向任何有效的结构体变量，它的值是未定义的。我们需要先创建一个结构体变量，然后让指针指向它。
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student stu = {"Tom", 20, 85.5};
struct Student *stuPtr = &stu;
return 0;
}
在上述代码中，首先定义了 struct Student 结构体，然后在 main 函数中创建了一个 stu 结构体变量，并初始化了其成员。接着定义了 stuPtr 指针，并通过 & 运算符让它指向 stu 结构体变量。
通过指向结构体的指针访问成员
当我们有了一个指向结构体的指针后，就可以通过该指针来访问结构体的成员。在 C 语言中，有两种方式可以通过指针访问结构体成员：使用 -> 运算符和间接访问后使用 . 运算符。
使用 -> 运算符
-> 运算符是专门用于通过指针访问结构体成员的。例如：
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student stu = {"Tom", 20, 85.5};
struct Student *stuPtr = &stu;
printf("Name: %s, Age: %d, Score: %.2f\n", stuPtr->name, stuPtr->age, stuPtr->score);
return 0;
}
在上述代码中，通过 stuPtr->name、stuPtr->age 和 stuPtr->score 分别访问了 stu 结构体变量的 name、age 和 score 成员。-> 运算符的左边是结构体指针，右边是结构体成员名。
使用间接访问后 . 运算符
另一种方式是先通过指针间接访问结构体变量，然后使用 . 运算符来访问成员。例如：
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student stu = {"Tom", 20, 85.5};
struct Student *stuPtr = &stu;
printf("Name: %s, Age: %d, Score: %.2f\n", (*stuPtr).name, (*stuPtr).age, (*stuPtr).score);
return 0;
}
这里 (*stuPtr) 首先通过指针 stuPtr 间接访问到 stu 结构体变量，然后使用 . 运算符来访问其成员。需要注意的是，(*stuPtr) 两边的括号是必须的，因为 . 运算符的优先级高于 * 运算符，如果不写括号，*stuPtr.name 会被解释为 *(stuPtr.name)，这通常不是我们想要的结果。
结构体指针作为函数参数
在 C 语言中，将结构体指针作为函数参数是一种非常常见且有效的方式，相比于传递整个结构体，传递结构体指针有以下优点：
- 效率更高：传递指针只需要传递一个地址值，而传递整个结构体可能需要传递大量的数据，尤其是结构体较大时，传递指针可以显著提高效率。
- 可以修改原结构体：通过传递指针，函数内部可以直接修改原结构体的内容，而传递结构体副本则无法直接影响原结构体。
下面是一个示例，展示如何将结构体指针作为函数参数：
struct Student {
char name[20];
int age;
float score;
};
void printStudent(struct Student *stuPtr) {
printf("Name: %s, Age: %d, Score: %.2f\n", stuPtr->name, stuPtr->age, stuPtr->score);
}
void increaseAge(struct Student *stuPtr) {
stuPtr->age++;
}
int main() {
struct Student stu = {"Tom", 20, 85.5};
printStudent(&stu);
increaseAge(&stu);
printStudent(&stu);
return 0;
}
在上述代码中，定义了两个函数 printStudent 和 increaseAge。printStudent 函数用于打印结构体的信息，increaseAge 函数用于将结构体中的 age 成员增加 1。在 main 函数中，创建了一个 stu 结构体变量，并将其地址传递给这两个函数。
动态内存分配与结构体指针
在实际编程中，我们常常需要动态地分配结构体的内存，而不是在栈上静态地定义。这可以通过 malloc、calloc 和 free 等函数来实现。
使用 malloc 函数分配结构体内存
malloc 函数用于分配指定字节数的内存空间，并返回一个指向该内存空间起始地址的指针。例如，为 struct Student 结构体分配内存：
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student *stuPtr = (struct Student *)malloc(sizeof(struct Student));
if (stuPtr == NULL) {
printf("Memory allocation failed\n");
return 1;
}
strcpy(stuPtr->name, "Jerry");
stuPtr->age = 21;
stuPtr->score = 90.0;
printf("Name: %s, Age: %d, Score: %.2f\n", stuPtr->name, stuPtr->age, stuPtr->score);
free(stuPtr);
return 0;
}
在上述代码中，使用 malloc 函数为 struct Student 结构体分配内存，并将返回的指针强制转换为 struct Student * 类型。然后检查指针是否为 NULL，以确保内存分配成功。接着对结构体成员进行赋值，并打印信息。最后使用 free 函数释放分配的内存。
使用 calloc 函数分配结构体内存
calloc 函数与 malloc 类似，但它会将分配的内存初始化为 0。例如：
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student *stuPtr = (struct Student *)calloc(1, sizeof(struct Student));
if (stuPtr == NULL) {
printf("Memory allocation failed\n");
return 1;
}
strcpy(stuPtr->name, "Alice");
stuPtr->age = 22;
stuPtr->score = 88.0;
printf("Name: %s, Age: %d, Score: %.2f\n", stuPtr->name, stuPtr->age, stuPtr->score);
free(stuPtr);
return 0;
}
这里使用 calloc 函数分配了一个 struct Student 结构体大小的内存空间，并初始化为 0。后续的使用与 malloc 类似。
结构体指针数组
结构体指针数组是一个数组，数组的每个元素都是一个指向结构体的指针。这种数据结构在处理多个结构体对象时非常有用。
定义和初始化结构体指针数组
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student stu1 = {"Tom", 20, 85.5};
struct Student stu2 = {"Jerry", 21, 90.0};
struct Student *stuArray[2] = {&stu1, &stu2};
for (int i = 0; i < 2; i++) {
printf("Name: %s, Age: %d, Score: %.2f\n", stuArray[i]->name, stuArray[i]->age, stuArray[i]->score);
}
return 0;
}
在上述代码中，首先定义了 struct Student 结构体，并创建了两个结构体变量 stu1 和 stu2。然后定义了一个 stuArray 结构体指针数组，其元素分别指向 stu1 和 stu2。通过循环遍历数组，打印每个结构体的信息。
动态分配结构体指针数组内存
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student **stuArray = (struct Student **)malloc(2 * sizeof(struct Student *));
if (stuArray == NULL) {
printf("Memory allocation failed\n");
return 1;
}
stuArray[0] = (struct Student *)malloc(sizeof(struct Student));
stuArray[1] = (struct Student *)malloc(sizeof(struct Student));
if (stuArray[0] == NULL || stuArray[1] == NULL) {
printf("Memory allocation failed\n");
for (int i = 0; i < 2; i++) {
if (stuArray[i] != NULL) {
free(stuArray[i]);
}
}
free(stuArray);
return 1;
}
strcpy(stuArray[0]->name, "Tom");
stuArray[0]->age = 20;
stuArray[0]->score = 85.5;
strcpy(stuArray[1]->name, "Jerry");
stuArray[1]->age = 21;
stuArray[1]->score = 90.0;
for (int i = 0; i < 2; i++) {
printf("Name: %s, Age: %d, Score: %.2f\n", stuArray[i]->name, stuArray[i]->age, stuArray[i]->score);
}
for (int i = 0; i < 2; i++) {
free(stuArray[i]);
}
free(stuArray);
return 0;
}
在这段代码中，首先使用 malloc 为结构体指针数组 stuArray 分配内存，然后为数组中的每个指针分配结构体内存。注意在分配内存时要检查是否成功，并且在使用完后要正确释放所有分配的内存，以避免内存泄漏。
结构体中包含指针成员
结构体中可以包含指针成员，这种情况在实际编程中也经常出现，比如链表和树等数据结构的实现。
简单示例
struct Node {
int data;
struct Node *next;
};
int main() {
struct Node node1 = {10, NULL};
struct Node node2 = {20, NULL};
node1.next = &node2;
struct Node *current = &node1;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
return 0;
}
在上述代码中，定义了一个 struct Node 结构体，它包含一个 int 类型的 data 成员和一个指向 struct Node 类型的 next 指针成员。通过将 node1 的 next 指针指向 node2，形成了一个简单的链表结构。然后通过遍历链表打印每个节点的数据。
动态创建链表
struct Node {
int data;
struct Node *next;
};
struct Node* createNode(int value) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
if (newNode == NULL) {
printf("Memory allocation failed\n");
return NULL;
}
newNode->data = value;
newNode->next = NULL;
return newNode;
}
void printList(struct Node *head) {
struct Node *current = head;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
}
int main() {
struct Node *head = createNode(10);
struct Node *node2 = createNode(20);
struct Node *node3 = createNode(30);
head->next = node2;
node2->next = node3;
printList(head);
return 0;
}
在这个示例中，定义了 createNode 函数用于动态创建链表节点，printList 函数用于打印链表中的所有数据。在 main 函数中，通过调用 createNode 函数创建了三个节点，并将它们连接成一个链表，最后调用 printList 函数打印链表。
指向结构体指针的指针
指向结构体指针的指针，即二级指针，在某些复杂的数据结构和算法中会用到。例如，在实现双向链表的插入和删除操作时，可能会用到指向结构体指针的指针。
示例代码
struct Student {
char name[20];
int age;
struct Student *next;
};
void addStudent(struct Student **head, const char *name, int age) {
struct Student *newStudent = (struct Student *)malloc(sizeof(struct Student));
if (newStudent == NULL) {
printf("Memory allocation failed\n");
return;
}
strcpy(newStudent->name, name);
newStudent->age = age;
newStudent->next = *head;
*head = newStudent;
}
void printStudents(struct Student *head) {
struct Student *current = head;
while (current != NULL) {
printf("Name: %s, Age: %d\n", current->name, current->age);
current = current->next;
}
}
int main() {
struct Student *head = NULL;
addStudent(&head, "Tom", 20);
addStudent(&head, "Jerry", 21);
printStudents(head);
return 0;
}
在上述代码中，addStudent 函数的第一个参数是一个指向 struct Student 指针的指针 head。这样在函数内部可以修改 head 指针本身，使其指向新添加的学生节点。如果只传递 struct Student * 类型的指针，函数内部只能修改指针所指向的结构体内容，而无法修改指针本身。
结构体指针与内存管理
在使用结构体指针时，内存管理是一个非常重要的问题。如果不正确地分配和释放内存，可能会导致内存泄漏和悬空指针等问题。
内存泄漏
内存泄漏是指分配的内存没有被释放，导致程序占用的内存不断增加。例如：
struct Student {
char name[20];
int age;
float score;
};
int main() {
while (1) {
struct Student *stuPtr = (struct Student *)malloc(sizeof(struct Student));
// 没有释放 stuPtr 指向的内存
}
return 0;
}
在上述代码中，每次循环都分配了内存，但没有使用 free 函数释放，随着循环的进行，内存会不断泄漏。
悬空指针
悬空指针是指指针指向的内存已经被释放，但指针仍然保留着原来的地址。例如：
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student *stuPtr = (struct Student *)malloc(sizeof(struct Student));
free(stuPtr);
// stuPtr 现在是悬空指针
// 如果继续使用 stuPtr 访问内存，会导致未定义行为
printf("%d\n", stuPtr->age);
return 0;
}
在上述代码中，free 函数释放了 stuPtr 指向的内存，但 stuPtr 仍然指向这个已释放的内存区域，成为悬空指针。如果继续通过 stuPtr 访问内存，会导致未定义行为，程序可能崩溃或产生其他错误。
为了避免内存泄漏和悬空指针问题，在分配内存时要确保有对应的释放操作，并且在释放内存后将指针设置为 NULL，以防止意外使用悬空指针。例如：
struct Student {
char name[20];
int age;
float score;
};
int main() {
struct Student *stuPtr = (struct Student *)malloc(sizeof(struct Student));
if (stuPtr != NULL) {
// 使用 stuPtr
free(stuPtr);
stuPtr = NULL;
}
return 0;
}
通过将指针设置为 NULL，可以避免意外使用悬空指针，因为对 NULL 指针进行解引用操作会导致程序在运行时崩溃，这样更容易发现和调试问题。
结构体指针在实际项目中的应用
在实际项目中，结构体指针有着广泛的应用，以下是一些常见的场景：
链表数据结构
链表是一种常用的数据结构，通过结构体指针实现节点之间的链接。链表的优点是插入和删除操作效率高，不需要连续的内存空间。例如，在实现一个简单的文件管理系统中，可以使用链表来管理文件节点，每个节点包含文件名、文件大小等信息，以及指向下一个文件节点的指针。
树状数据结构
树状数据结构如二叉树、B 树等，也大量使用结构体指针。在二叉树中，每个节点包含数据和两个指向左右子节点的指针。树状结构常用于搜索、排序等算法中，在数据库索引、文件系统目录结构等方面都有应用。
图形处理
在图形处理中，结构体指针可用于表示图形的顶点、边等元素。例如，在实现一个简单的二维图形绘制程序时，可以使用结构体指针来构建图形的几何模型，通过指针操作实现图形的变换、渲染等功能。
操作系统内核
在操作系统内核中，结构体指针用于管理各种系统资源，如进程控制块（PCB）、内存管理单元（MMU）等。每个进程控制块可以是一个结构体，包含进程的状态、优先级、内存分配信息等，通过结构体指针实现进程的调度、切换等操作。
总之，结构体指针在 C 语言编程中是一个非常强大且重要的工具，深入理解和掌握它的应用对于编写高效、健壮的程序至关重要。无论是简单的程序还是复杂的大型项目，结构体指针都发挥着不可或缺的作用。通过合理地使用结构体指针，可以优化内存使用、提高程序性能，并实现复杂的数据结构和算法。希望通过本文的介绍，读者对指向结构体的指针有更深入的理解和认识，能够在实际编程中灵活运用这一技术。