5个例子告诉你:C语言结构体的高级难度玩法

当涉及到C语言结构体的高级玩法时，有一些更具挑战性的例子可以探索。以下是另外五个高级难度的例子代码，涵盖了更多复杂的结构体用法和概念。

1.函数指针数组结构体（Structure with Function Pointer Array）

#include 

typedef int (*MathOperation)(int, int);

struct MathOperations {
    MathOperation operations[3];
};

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int multiply(int a, int b) {
    return a * b;
}

int main() {
    struct MathOperations math;

    math.operations[0] = add;
    math.operations[1] = subtract;
    math.operations[2] = multiply;

    int a = 5;
    int b = 3;

    for (int i = 0; i < 3; i++) {
        int result = math.operations[i](a, b);
        printf("Operation %d result: %d\n", i+1, result);
    }

    return 0;
}

在这个例子中，我们定义了一个包含函数指针数组的结构体MathOperations。数组中的每个元素都是一个函数指针，指向不同的数学操作函数。我们将加法、减法和乘法函数分别分配给数组中的元素，并通过遍历数组来调用不同的数学操作。

2.结构体嵌套自身（Structure Nesting Itself）

#include 

struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
};

void traverseTree(struct TreeNode* node) {
    if (node == NULL)
        return;

    printf("%d ", node->data);
    traverseTree(node->left);
    traverseTree(node->right);
}

int main() {
    struct TreeNode node1, node2, node3, node4, node5;
    node1.data = 1;
    node2.data = 2;
    node3.data = 3;
    node4.data = 4;
    node5.data = 5;

    node1.left = &node2;
    node1.right = &node3;
    node2.left = &node4;
    node2.right = NULL;
    node3.left = &node5;
    node3.right = NULL;
    node4.left = NULL;
    node4.right = NULL;
    node5.left = NULL;
    node5.right = NULL;

    traverseTree(&node1);
    return 0;
}

在这个例子中，我们定义了一个结构体TreeNode，表示二叉树的节点。结构体中包含一个整数数据成员以及两个指向相同结构体类型的指针成员，分别指向左子节点和右子节点。通过嵌套结构体自身，我们可以创建复杂的树状数据结构。在main()函数中，我们手动创建了一个二叉树，并使用递归函数traverseTree()遍历并打印树的节点。

3. 灵活数组成员

在C语言中，结构体中的数组成员必须具有固定大小，不能实现灵活的数组成员。以下是一个重新调整的例子，展示了如何使用指针实现动态大小的数组。

#include 
#include 

struct DynamicArray {
    int* array;
    int size;
};

struct DynamicArray* createDynamicArray(int size) {
    struct DynamicArray* dynamicArray = malloc(sizeof(struct DynamicArray));
    dynamicArray->array = malloc(sizeof(int) * size);
    dynamicArray->size = size;
    return dynamicArray;
}

void freeDynamicArray(struct DynamicArray* dynamicArray) {
    free(dynamicArray->array);
    free(dynamicArray);
}

int main() {
    int size = 5;
    struct DynamicArray* myArray = createDynamicArray(size);

    for (int i = 0; i < myArray->size; i++) {
        myArray->array[i] = i + 1;
    }

    printf("Array elements: ");
    for (int i = 0; i < myArray->size; i++) {
        printf("%d ", myArray->array[i]);
    }
    printf("\n");

    freeDynamicArray(myArray);

    return 0;
}

在这个例子中，我们定义了一个DynamicArray结构体，其中包含一个array指针和一个size成员。array指针指向动态分配的整数数组，而size表示数组的大小。

通过createDynamicArray()函数，我们可以动态地创建一个具有指定大小的动态数组，并返回一个指向该结构体的指针。在main()函数中，我们使用createDynamicArray()函数创建一个大小为5的动态数组，并使用循环将一些值存储在数组中。最后，我们使用freeDynamicArray()函数释放动态分配的内存。

请注意，这个例子展示了使用指针来模拟动态大小的数组，而不是直接在结构体中定义灵活的数组成员。

4.结构体的递归嵌套（Recursive Nesting of Structures）

#include 

struct Node {
    int data;
    struct Node* next;
};

void printLinkedList(struct Node* node) {
    if (node == NULL)
        return;

    printf("%d ", node->data);
    printLinkedList(node->next);
}

int main() {
    struct Node node1, node2, node3;

    node1.data = 1;
    node2.data = 2;
    node3.data = 3;

    node1.next = &node2;
    node2.next = &node3;
    node3.next = NULL;

    printLinkedList(&node1);

    return 0;
}

在这个例子中，我们定义了一个简单的链表结构体Node，其中包含一个整数数据成员和一个指向相同结构体类型的指针成员next。通过递归嵌套结构体自身，我们可以创建链表结构。在main()函数中，我们手动创建了一个简单的链表，并使用递归函数printLinkedList()打印链表中的数据。

5.结构体指针数组（Array of Structure Pointers）

#include 

struct Person {
    char name[20];
    int age;
};

int main() {
    struct Person person1 = { "Alice", 25 };
    struct Person person2 = { "Bob", 30 };
    struct Person person3 = { "Charlie", 35 };

    struct Person* people[] = { &person1, &person2, &person3 };

    for (int i = 0; i < 3; i++) {
        printf("Person %d: Name: %s, Age: %d\n", i+1, people[i]->name, people[i]->age);
    }

    return 0;
}

在这个例子中，我们定义了一个Person结构体，表示一个人的信息，包含一个名字（字符串）和一个年龄（整数）。然后，我们创建了几个Person类型的变量，并使用指针数组people存储了这些结构体的指针。

在main()函数中，我们使用循环遍历指针数组，并通过指针访问结构体成员，打印每个人的名字和年龄。