C阵列列表崩溃

我的arraylist文件：

#include <stdint.h>
#include <malloc.h>
#include <memory.h>
#include <stdio.h>

#include "ArrayList.h"


typedef struct ArrayList {
    uint32_t size;
    void **data;

    uint32_t capacity;
} ArrayList;


ArrayList *arrayList_construct(uint32_t initialCapacity) {
    if (initialCapacity < 10) {
        initialCapacity = 10;
    }
    ArrayList *arrayList = malloc(sizeof(ArrayList));
    arrayList->size = 0;
    arrayList->capacity = initialCapacity;
    arrayList->data = malloc(initialCapacity * sizeof(void *));
    return arrayList;
}

void arrayList_add(ArrayList *arrayList, void *item) {
    ensureCapacity(arrayList);
    *(arrayList->data + arrayList->size) = item;
    arrayList->size++;
}

void arrayList_set(ArrayList *arrayList, uint32_t index, void *value) {
    *(arrayList->data + index) = value;
}

void *arrayList_get(ArrayList *arrayList, uint32_t index) {
    return *(arrayList->data + index);
}

void arrayList_remove(ArrayList *arrayList, uint32_t index) {
    memcpy(arrayList->data + index, arrayList->data + index + 1, (arrayList->size - index - 1) * sizeof(void *));
    free(*(arrayList->data + arrayList->size-- - 1));
}

uint32_t arrayList_getSize(ArrayList *arrayList) {
    return arrayList->size;
}

void arrayList_destruct(ArrayList *arrayList) {
    free(arrayList->data);
    free(arrayList);
}

static void ensureCapacity(ArrayList *arrayList) {
    if (arrayList->size >= arrayList->capacity) {
        uint32_t oldCapacity = arrayList->capacity;
        uint32_t newCapacity = oldCapacity + (oldCapacity >> 1) * 2;
        arrayList->capacity = newCapacity;

        void **newSpace = malloc(sizeof(void *) * newCapacity);
        void **oldSpace = arrayList->data;
        arrayList->data = memcpy(newSpace, oldSpace, oldCapacity);
        free(oldSpace);
    }
}

int main() {
    ArrayList *arrayList = arrayList_construct((uint32_t) 10);


    int *array = malloc(100 * sizeof(int));
    for (int i = 0; i < 100; ++i) {
        *(array + i) = i;
        arrayList_add(arrayList, array + i);
    }

    for (int i = 0; i < arrayList_getSize(arrayList); i++) {
        printf("[%p]: %d\n", arrayList_get(arrayList, i), *(int *) arrayList_get(arrayList, i));
    }

    return 0;
}

#包括
#包括
#包括
#包括
#包括“ArrayList.h”
类型定义结构数组列表{
uint32_t尺寸；
作废**数据；
uint32_t容量；
}ArrayList；
ArrayList*ArrayList_构造（uint32_t初始容量）{
如果（初始容量<10）{
初始容量=10；
}
ArrayList*ArrayList=malloc（sizeof（ArrayList））；
arrayList->size=0；
arrayList->capacity=初始容量；
arrayList->data=malloc（初始容量*sizeof（void*）；
返回数组列表；
}
void arrayList_add（arrayList*arrayList，void*item）{
保证能力（arrayList）；
*（arrayList->data+arrayList->size）=项目；
arrayList->size++；
}
void arrayList_set（arrayList*arrayList，uint32_t索引，void*值）{
*（arrayList->data+index）=值；
}
void*arrayList\u get（arrayList*arrayList，uint32\u t索引）{
返回*（数组列表->数据+索引）；
}
void arrayList_remove（arrayList*arrayList，uint32_t索引）{
memcpy（arrayList->data+index，arrayList->data+index+1，（arrayList->size-index-1）*sizeof（void*）；
自由（*（arrayList->data+arrayList->size--1））；
}
uint32\u t arrayList\u getSize（arrayList*arrayList）{
返回arrayList->size；
}
void arrayList_destruct（arrayList*arrayList）{
免费（arrayList->data）；
免费（arrayList）；
}
静态容量（ArrayList*ArrayList）{
如果（arrayList->size>=arrayList->capacity）{
uint32\u t oldCapacity=arrayList->capacity；
uint32\u t新容量=旧容量+（旧容量>>1）*2；
arrayList->capacity=newCapacity；
void**newSpace=malloc（sizeof（void*）*newCapacity）；
void**oldSpace=arrayList->data；
arrayList->data=memcpy（新闻空间、旧空间、旧容量）；
免费（旧空间）；
}
}
int main（）{
ArrayList*ArrayList=ArrayList_构造（（uint32_t）10）；
int*array=malloc（100*sizeof（int））；
对于（int i=0；i<100；++i）{
*（数组+i）=i；
arrayList_add（arrayList，array+i）；
}
for（int i=0；i

当我在arraylist中放入10个对象时，它可以正常工作。 但当我在其中放入更多对象（100）时，它崩溃（内存访问冲突）。 它打印前两个对象，然后崩溃

---

如何解决此问题？

问题很可能是如何复制内存：

memcpy(newSpace, oldSpace, oldCapacity);

---

第三个参数是以字节为单位的大小。您需要将其与sizeof（void*）相乘以获得正确的大小。

当您已经知道arrylist的大小时，声明arrylist的更好选项是

ArrayList *arrayList[size]

但如果您不知道大小，则首选的方法是使用链表。i、 e创建一个元素并将其附加到列表中

在当前状态下，另一件有用的事情是使用

void *realloc(void *ptr, size_t size)

---

不要在ensureCapacity函数中使用malloc。

为什么不使用？堆有多大？如果我破坏这个arraylist，我是否也需要释放每个元素？@user2997204我想说这不是arraylist或其析构函数的责任，而是它的用户的责任。如果列表中的指针指向堆上未动态分配的数据，该怎么办？