面试题：Rust函数指针在复杂数据结构中的应用与内存管理优化

实现思路

定义数据结构：

首先定义链表节点结构，每个节点包含多个嵌套结构体。例如：

struct InnerStruct1 {
    int value1;
    // 其他成员
};
struct InnerStruct2 {
    char text[50];
    // 其他成员
};
struct ListNode {
    struct InnerStruct1 inner1;
    struct InnerStruct2 inner2;
    struct ListNode* next;
};

函数指针定义：
- 为节点排序和数据处理等操作定义函数指针类型。
- 例如，对于节点排序，可以定义比较函数指针类型：
```
typedef int (*CompareFunc)(const struct ListNode* a, const struct ListNode* b);
```
- 这里CompareFunc是一个函数指针类型，指向的函数接受两个const struct ListNode*类型的参数，返回一个int类型的值，用于比较两个节点。
- 对于节点数据处理，可以定义处理函数指针类型：
```
typedef void (*ProcessFunc)(struct ListNode* node);
```
- 这里ProcessFunc是一个函数指针类型，指向的函数接受一个struct ListNode*类型的参数，返回void，用于对节点数据进行处理。

链表操作函数：

排序操作：实现一个排序函数，使用函数指针作为参数来决定排序逻辑。例如使用冒泡排序：

void sortList(struct ListNode** head, CompareFunc compare) {
    int swapped;
    struct ListNode* ptr1;
    struct ListNode* lptr = NULL;
    if (head == NULL)
        return;
    do {
        swapped = 0;
        ptr1 = *head;
        while (ptr1->next != lptr) {
            if (compare(ptr1, ptr1->next) > 0) {
                struct ListNode* temp = ptr1;
                ptr1 = ptr1->next;
                temp->next = ptr1->next;
                ptr1->next = temp;
                if (ptr1 == *head) {
                    *head = ptr1;
                }
                swapped = 1;
            }
            else {
                ptr1 = ptr1->next;
            }
        }
        lptr = ptr1;
    } while (swapped);
}

数据处理操作：实现一个遍历链表并处理节点数据的函数，使用函数指针来决定处理逻辑。

void processList(struct ListNode* head, ProcessFunc process) {
    struct ListNode* current = head;
    while (current != NULL) {
        process(current);
        current = current->next;
    }
}

具体函数实现：

为CompareFunc和ProcessFunc定义具体的实现函数。例如，比较函数可以根据InnerStruct1中的value1进行比较：

int compareByValue1(const struct ListNode* a, const struct ListNode* b) {
    return a->inner1.value1 - b->inner1.value1;
}

处理函数可以对InnerStruct2中的text进行一些修改，比如转换为大写：

#include <ctype.h>
void processTextToUpper(struct ListNode* node) {
    for (int i = 0; node->inner2.text[i] != '\0'; i++) {
        node->inner2.text[i] = toupper(node->inner2.text[i]);
    }
}

调用操作：

在主函数或其他调用处，创建链表，调用排序和数据处理函数。

int main() {
    // 创建链表并初始化节点
    struct ListNode* head = createList();
    sortList(&head, compareByValue1);
    processList(head, processTextToUpper);
    // 释放链表内存
    freeList(head);
    return 0;
}

内存管理难点及解决方法

难点：
- 链表节点内存分配：在创建链表节点时，需要为每个节点及其内部嵌套结构体分配内存。如果分配失败，可能导致程序崩溃。同时，如果分配过多未释放，会造成内存泄漏。
- 嵌套结构体内存管理：内部嵌套结构体可能包含动态分配的内存，如InnerStruct2中的text数组如果是动态分配的（如char* text = (char*)malloc(50);），在释放链表节点时需要正确释放这些内部动态分配的内存，否则也会导致内存泄漏。
- 函数指针相关内存：虽然函数指针本身不涉及动态内存分配，但如果函数指针指向的函数内部有动态内存分配，在调用后需要确保正确释放。例如，如果ProcessFunc指向的函数中动态分配了内存，调用者需要知道如何正确释放。
解决方法：
- 链表节点内存管理：在创建链表节点时，使用malloc或calloc分配内存，并检查返回值是否为NULL，以确保分配成功。在释放链表时，遍历链表，逐个释放每个节点的内存。例如：
```
void freeList(struct ListNode* head) {
    struct ListNode* current = head;
    struct ListNode* next;
    while (current != NULL) {
        next = current->next;
        free(current);
        current = next;
    }
}
```
- 嵌套结构体内存管理：如果嵌套结构体中有动态分配的内存，在释放链表节点前，先释放嵌套结构体中动态分配的内存。例如，如果InnerStruct2中的text是动态分配的：
```
void freeList(struct ListNode* head) {
    struct ListNode* current = head;
    struct ListNode* next;
    while (current != NULL) {
        next = current->next;
        free(current->inner2.text);
        free(current);
        current = next;
    }
}
```
- 函数指针相关内存：对于函数指针指向的函数中动态分配的内存，应该在函数内部提供释放内存的机制，或者在函数文档中明确说明调用者如何释放。例如，ProcessFunc指向的函数如果动态分配了内存，可以在函数内部提供一个释放函数，或者返回一个包含释放函数指针的结构体，供调用者使用。同时，在设计函数时，尽量避免在函数指针指向的函数中进行不必要的动态内存分配，以简化内存管理。

星途面试题库

面试题：Rust函数指针在复杂数据结构中的应用与内存管理优化

知识考点

面试题答案

实现思路

内存管理难点及解决方法