如何在C语言中创建支持动态数据类型的链表？

嘿，这个问题问得好！C语言本身没有Java那样的原生泛型机制，但我们可以通过一些实用技巧来实现类似的动态类型链表，核心思路就是利用void指针存储任意类型数据，再配合类型标记或宏定义来保证操作的安全性。下面给你详细拆解两种可行方案：

1. 基础方案：用void*存储任意类型数据 #

最直接的方式是把节点里的data和key改成void*类型——它可以指向任何数据（int、字符串、自定义结构体都没问题）。不过要注意两点：一是要自己手动管理内存，二是最好加个类型标记，避免操作时出现类型错误。

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义带类型标记的链表节点
struct node {
    void *data;
    void *key;
    // 用枚举标记数据类型，方便后续识别
    enum { TYPE_INT, TYPE_STRING, TYPE_CUSTOM } data_type;
    enum { TYPE_INT_KEY, TYPE_STRING_KEY } key_type;
    struct node *next;
};

// 创建新节点的函数（自动复制数据，避免临时变量指针失效）
struct node* create_node(void *data, void *key, int data_type, int key_type) {
    struct node *new_node = malloc(sizeof(struct node));
    if (!new_node) return NULL;

    // 根据类型复制data
    switch(data_type) {
        case TYPE_INT:
            new_node->data = malloc(sizeof(int));
            *(int*)new_node->data = *(int*)data;
            break;
        case TYPE_STRING:
            new_node->data = malloc(strlen((char*)data) + 1);
            strcpy((char*)new_node->data, (char*)data);
            break;
        case TYPE_CUSTOM:
            // 假设自定义结构体是struct MyObject，需手动指定大小
            new_node->data = malloc(sizeof(struct MyObject));
            memcpy(new_node->data, data, sizeof(struct MyObject));
            break;
    }

    // 同理复制key
    switch(key_type) {
        case TYPE_INT_KEY:
            new_node->key = malloc(sizeof(int));
            *(int*)new_node->key = *(int*)key;
            break;
        case TYPE_STRING_KEY:
            new_node->key = malloc(strlen((char*)key) + 1);
            strcpy((char*)new_node->key, (char*)key);
            break;
    }

    new_node->data_type = data_type;
    new_node->key_type = key_type;
    new_node->next = NULL;
    return new_node;
}

// 打印节点数据的示例函数
void print_node(struct node *n) {
    switch(n->data_type) {
        case TYPE_INT:
            printf("Data: %d\n", *(int*)n->data);
            break;
        case TYPE_STRING:
            printf("Data: %s\n", (char*)n->data);
            break;
        case TYPE_CUSTOM:
            // 自定义结构体需自己实现打印逻辑
            print_my_object((struct MyObject*)n->data);
            break;
    }
}

// 释放节点内存（必须手动释放data和key，避免泄漏）
void free_node(struct node *n) {
    free(n->data);
    free(n->key);
    free(n);
}

2. 进阶方案：用宏模拟泛型 #

如果想让代码更贴近Java泛型的写法，可以用C语言的宏来生成特定类型的链表。这样每个类型的链表都是独立的，不需要类型标记，类型安全性更高。

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 宏定义：自动生成特定类型的链表节点和操作函数
#define DEFINE_LINKED_LIST(type_name, data_type, key_type) \
typedef struct type_name##_node { \
    data_type data; \
    key_type key; \
    struct type_name##_node *next; \
} type_name##_node; \
\
type_name##_node* type_name##_create_node(data_type data, key_type key) { \
    type_name##_node *new_node = malloc(sizeof(type_name##_node)); \
    if (!new_node) return NULL; \
    new_node->data = data; \
    new_node->key = key; \
    new_node->next = NULL; \
    return new_node; \
} \
\
void type_name##_print_node(type_name##_node *n) { \
    printf("Data: "); \
    // 用_Generic自动适配不同类型的打印方式
    _Generic((n->data), \
        int: printf("%d\n", n->data), \
        char*: printf("%s\n", n->data) \
    ); \
}

// 生成int类型的链表（对应Java的List<Integer>）
DEFINE_LINKED_LIST(IntList, int, int)
// 生成字符串类型的链表（对应Java的List<String>）
DEFINE_LINKED_LIST(StringList, char*, char*)
// 生成自定义结构体的链表（需先定义struct MyObject）
// DEFINE_LINKED_LIST(MyObjectList, struct MyObject, int)

int main() {
    // 使用int类型链表
    IntList_node *int_node = IntList_create_node(100, 1);
    IntList_print_node(int_node);

    // 使用字符串类型链表
    char *str_data = "Hello C Generic List";
    char *str_key = "str_key_1";
    StringList_node *str_node = StringList_create_node(str_data, str_key);
    StringList_print_node(str_node);

    // 记得释放内存
    free(int_node);
    free(str_node);
    return 0;
}

关键注意事项 #

• 内存管理：用void*时，必须手动分配和释放数据内存，否则极易出现内存泄漏或野指针问题。
• 类型安全：C语言没有运行时类型检查，操作时要确保数据类型和标记的类型一致，否则会触发未定义行为。
• 宏的局限性：宏生成的泛型链表是独立的，无法像Java那样用统一接口操作不同类型的链表，代码可读性也会稍差。

内容的提问来源于stack exchange，提问作者Program-Me-Rev