Question

typedef struct {
    void **head;
    size_t used_size;
    size_t free_size;
    size_t current_size;
    size_t size_increment;
} GrowingArray;

GrowingArray createEmptyGrowingArray(int initial_size, int size_increment) {
    GrowingArray empty_growing_array;
    empty_growing_array.head = malloc(initial_size * sizeof(void *));
    empty_growing_array.used_size = 0;
    empty_growing_array.free_size = initial_size;
    empty_growing_array.current_size = initial_size;
    empty_growing_array.size_increment = size_increment;

    return empty_growing_array;
}

GrowingArray appendToGrowingArray(GrowingArray growing_array, void *new_element) {

    void *new_head_of_array;

    if (growing_array.free_size == 0) {
        new_head_of_array = realloc(growing_array.head, (growing_array.current_size + growing_array.size_increment) * sizeof(void*));
        if (new_head_of_array == NULL) {
            printf("Reallocation failure.\n");
        }

        growing_array.free_size = growing_array.size_increment;
        growing_array.current_size += growing_array.size_increment;
        growing_array.head = new_head_of_array;
    }

    growing_array.head[growing_array.used_size++] = new_element;
    growing_array.free_size--;

    return growing_array;
}

void finalizeGrowingArrayMemory(GrowingArray growing_array) {
    growing_array.head = realloc(growing_array.head, growing_array.current_size * sizeof(void *));
}

void freeGrowingArray(GrowingArray growing_array) {
    free(growing_array.head);
}

int main(int argc, char* argv[]) {
    GrowingArray test_array = createEmptyGrowingArray(5, 1);

    int *test_integer = (int *)malloc(1 * sizeof(int));
    *test_integer = 4;

    int *another_integer = (int *)malloc(1 * sizeof(int));
    *another_integer = 6;

    int *yet_another_integer = (int *)malloc(sizeof(int));
    *yet_another_integer = 9;

    test_array = appendToGrowingArray(test_array, test_integer);
    test_array = appendToGrowingArray(test_array, another_integer);
    test_array = appendToGrowingArray(test_array, yet_another_integer);
    finalizeGrowingArrayMemory(test_array);

    printf("%x,", *(int *)test_array.head[0]);
    printf("%x,", *(int *)test_array.head[1]);
    printf("%x\n", *(int *)test_array.head[2]);

    freeGrowingArray(test_array);

    printf("Going to free %llx\n", (long long int)test_integer);
    free(test_integer);

    printf("Going to free %llx\n", (long long int)another_integer);
    free(another_integer);

    printf("Going to free %llx\n", (long long int)yet_another_integer);
    free(yet_another_integer);

    return 0;
}

我根据此问题的正确答案中提供的示例代码编写了此代码：How may I implement a generic, dynamically growing array in C?

提供的答案包括一个简单地重新分配指针数组的函数。预期的用法是在将几个项目附加到数组后调用它，如答案代码中所示。

我想知道为什么要这样做。它提供了什么好处？ realloc（）是否尝试根据其先前的用法对内存块的使用方式进行预测，然后将其移动到最佳位置？

谢谢！

作为附加组件是或否的问题：我应该在calloc()内使用malloc()代替createEmptyGrowingArray()吗？

Answer 1

我想知道为什么要这样做。它提供了什么好处？

我认为你在问为什么它有一个功能，或者为什么有一个可配置的增量：

将重新分配详细信息分离到自己的区域以避免使代码混乱，并提供可重用的调整大小操作，可以从可能实现的其他形式的“插入”调用中调用，这很方便。
具有增量配置允许您通过多个元素放大数组，从而防止过多的重新分配。
虽然您的示例没有这样做，但增加增量大小也很有用。这将允许constant amortized time complexity进行数组增长。

realloc（）是否尝试根据其先前的使用情况对内存块的使用方式进行预测，然后将其移动到认为最佳的位置？

不，它不知道您的块用于什么。它只是分配了一大块内存。如果它可以在不移动内存的情况下调整大小，它就会。但是如果没有足够的空间，或者它必须被移动到不同的分配方案（内存管理器经常根据它们的大小将块分成不同的区域），那么指针将移动并且该内存的内容将被复制到新的位置。

作为附加组件是或否的问题：我应该在createEmptyGrowingArray（）中使用calloc（）而不是malloc（）吗？

使用calloc是合理的做法，但是当您创建一个空数组时，请记住您将当前大小设置为零，因此malloc就足够了，因为您不打算使用那些未初始化的值，直到你稍后初始化它们（在追加之后）。此外，在调用realloc来增加块之后，您当前没有将新内存中的指针归零，因此它不会为您的“创建”操作提供概念上的奇偶校验。

因此，在您的情况下，我会争辩使用malloc，这不会对未使用数据的状态提出不切实际的期望。如果您想在创建时使用calloc，那么您还应该使用memset在增长后将新内存清零。

为什么需要realloc（）内存来增加指针数量？

1 个答案: