c语言用类封装单向链表

C语言中没有类的概念，但可以使用结构体和函数指针来实现链表的封装，下面是一个简单的单向链表封装示例。

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

typedef struct _node {
    int value;
    struct _node* next;
} ListNode;

typedef struct _linked_list {
    ListNode* head;
    int size;
    void (*insert)(struct _linked_list*, int);
    void (*remove)(struct _linked_list*, int);
    void (*print)(struct _linked_list*);
    void (*clear)(struct _linked_list*);
} LinkedList;

void insert(LinkedList* list, int value) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->value = value;
    node->next = NULL;

    if (list->head == NULL) {
        list->head = node;
    } else {
        ListNode* cur = list->head;
        while (cur->next) {
            cur = cur->next;
        }
        cur->next = node;
    }

    list->size++;
}

void remove_node(LinkedList* list, int value) {
    ListNode* cur = list->head;
    ListNode* prev = NULL;

    while (cur) {
        if (cur->value == value) {
            if (prev == NULL) {
                list->head = cur->next;
            } else {
                prev->next = cur->next;
            }
            free(cur);
            list->size--;
            return;
        }
        prev = cur;
        cur = cur->next;
    }
}

void print(LinkedList* list) {
    ListNode* cur = list->head;

    while (cur) {
        printf("%d ", cur->value);
        cur = cur->next;
    }

    printf("\n");
}

void clear(LinkedList* list) {
    ListNode* cur = list->head;

    while (cur) {
        ListNode* next = cur->next;
        free(cur);
        cur = next;
    }

    list->head = NULL;
    list->size = 0;
}

LinkedList* new_linked_list() {
    LinkedList* list = (LinkedList*)malloc(sizeof(LinkedList));
    list->head = NULL;
    list->size = 0;
    list->insert = insert;
    list->remove = remove_node;
    list->print = print;
    list->clear = clear;

    return list;
}

int main() {
    LinkedList* list = new_linked_list();

    list->insert(list, 1);
    list->insert(list, 2);
    list->insert(list, 3);

    list->print(list);

    list->remove(list, 2);

    list->print(list);

    list->clear(list);
    free(list);

    return 0;
}

在这个示例中，我们首先定义了两个结构体：`ListNode`和`LinkedList`。`ListNode`表示链表节点，包含一个整数值和指向下一个节点的指针。`LinkedList`表示链表本身，包含指向头节点的指针和链表中节点的数量，以及链表操作的函数指针。

然后，我们定义了一些函数来操作链表。`insert`函数用于在链表末尾插入一个新节点，新节点的值为传入的参数。`remove_node`函数用于从链表中删除一个节点，值为传入的参数。`print`函数用于打印链表中所有节点的值。`clear`函数用于清空链表中的所有节点，释放内存。

在`new_linked_list`函数中，我们创建了一个新的`LinkedList`对象，并将链表操作的函数指针赋值给相应的成员变量。在`main`函数中，我们使用`new_linked_list`函数创建了一个新的链表对象，然后使用链表操作的函数指针来操作链表。

这个示例只是一个简单的单向链表封装，如果需要更复杂的功能，可以在`LinkedList`结构体中添加更多的成员变量和函数，并在函数中实现更多的链表操作。