C语言结构体函数指针：面向对象风格实现ArrayList技术问询

看起来你已经有了用C模拟Java ArrayList的初步思路，我来帮你完善这个实现，从结构体定义到核心方法，再到使用示例，一步步解决可能遇到的问题：

首先需要给结构体补充动态数组的核心成员，同时扩展函数指针来支持更多常用操作：

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

// 用typedef简化结构体名称，模拟面向对象的"类"
typedef struct ArrayList {
    void** elements;       // 存储任意类型元素的动态指针数组（类似Java泛型）
    int size;              // 当前已存储的元素数量
    int capacity;          // 数组的总容量（可容纳的最大元素数）
    // 函数指针，对应类的"成员方法"
    void (*add)(struct ArrayList* list, void* element);
    void* (*get)(struct ArrayList* list, int index);
    int (*getSize)(struct ArrayList* list);
    void (*destroy)(struct ArrayList* list);
} ArrayList;

注意：用void**是为了让ArrayList支持任意类型的元素，和Java的泛型逻辑一致，使用时需要手动处理类型转换。

1. 动态扩容函数（内部私有方法） #

当元素数量达到容量上限时，需要自动扩容，这里我们采用扩容至原容量2倍的策略（也可以根据需求改成1.5倍，更节省内存）：

static void resize(ArrayList* list) {
    if (list == NULL) return;
    // 初始容量为0时，先设置为4作为初始值
    int new_capacity = list->capacity == 0 ? 4 : list->capacity * 2;
    void** new_elements = realloc(list->elements, new_capacity * sizeof(void*));
    if (new_elements == NULL) {
        fprintf(stderr, "Memory allocation failed during resize!\n");
        exit(EXIT_FAILURE);
    }
    list->elements = new_elements;
    list->capacity = new_capacity;
}

用static修饰是因为这个函数只在内部使用，不需要暴露给外部调用者。

2. add方法实现 #

在列表末尾添加元素，先检查是否需要扩容，再存入元素指针：

static void arrayList_add(ArrayList* list, void* element) {
    if (list == NULL || element == NULL) return;
    // 容量不足时自动扩容
    if (list->size >= list->capacity) {
        resize(list);
    }
    list->elements[list->size++] = element;
}

3. get方法实现 #

根据索引获取元素，必须做越界检查避免段错误：

static void* arrayList_get(ArrayList* list, int index) {
    if (list == NULL || index < 0 || index >= list->size) {
        fprintf(stderr, "Error: Index out of bounds or invalid ArrayList!\n");
        return NULL;
    }
    return list->elements[index];
}

4. getSize方法实现 #

返回当前列表的元素数量：

static int arrayList_getSize(ArrayList* list) {
    return list == NULL ? 0 : list->size;
}

5. destroy方法实现 #

释放ArrayList占用的内存，注意要提醒用户手动释放元素内存：

static void arrayList_destroy(ArrayList* list) {
    if (list == NULL) return;
    // 仅释放ArrayList自身和elements数组的内存
    // 如果元素是动态分配的（如malloc/strdup），需要用户提前手动释放！
    free(list->elements);
    free(list);
}

初始化结构体成员，并将函数指针绑定到对应方法上，模拟Java的构造函数：

ArrayList* newArrayList() {
    ArrayList* list = malloc(sizeof(ArrayList));
    if (list == NULL) {
        fprintf(stderr, "Failed to create ArrayList instance!\n");
        return NULL;
    }
    // 初始化核心成员
    list->elements = NULL;
    list->size = 0;
    list->capacity = 0;
    // 绑定方法到函数指针
    list->add = arrayList_add;
    list->get = arrayList_get;
    list->getSize = arrayList_getSize;
    list->destroy = arrayList_destroy;
    return list;
}

展示如何用这个ArrayList存储不同类型的元素：

int main() {
    // 创建ArrayList实例
    ArrayList* myList = newArrayList();
    if (myList == NULL) return 1;

    // 添加int类型元素（需用指针存储，这里用动态分配）
    int* num1 = malloc(sizeof(int));
    *num1 = 100;
    myList->add(myList, num1);

    int* num2 = malloc(sizeof(int));
    *num2 = 200;
    myList->add(myList, num2);

    // 添加字符串类型元素
    char* msg = strdup("Hello, C-style ArrayList!");
    myList->add(myList, msg);

    // 打印列表信息和元素
    printf("List size: %d\n", myList->getSize(myList));
    printf("Element at index 0: %d\n", *(int*)myList->get(myList, 0));
    printf("Element at index 1: %d\n", *(int*)myList->get(myList, 1));
    printf("Element at index 2: %s\n", (char*)myList->get(myList, 2));

    // 手动释放元素内存（必须在destroy之前）
    free(myList->get(myList, 0));
    free(myList->get(myList, 1));
    free(myList->get(myList, 2));

    // 销毁ArrayList实例
    myList->destroy(myList);
    return 0;
}

• 内存泄漏：必须调用destroy方法释放ArrayList的内存；如果元素是动态分配的，一定要在destroy之前手动释放元素，否则会造成内存泄漏。
• 类型错误：因为用了void*，获取元素时必须强制类型转换（如*(int*)），确保类型和存入时一致，否则会出现未定义行为。
• 扩容效率：如果你的场景中元素数量增长稳定，可以调整扩容倍数（比如1.5倍），减少内存浪费；如果需要频繁扩容，也可以在构造函数中支持指定初始容量。
• 空指针崩溃：所有方法都做了NULL检查，调用时尽量避免传入空指针，防止程序崩溃。

内容的提问来源于stack exchange，提问作者Nandan Desai