How can I implement a generic, dynamically growing array in C?

My requirements:

• The data structure must contain an arbitrary number of elements (on the order of hundreds of thousands).
• The data structure must use memory efficiently. In this case, it means adding additional hundreds of thousands of items when needed.
• The data structure must contain elements of an unknown but uniform type.

The way I expected to be able to build it was to define a structure representing an array. The structure contained the length of the array and the number of elements in the array. It also contained a pointer to an array of void pointers that yielded the actual data.

The pointer was used as memory was equal to malloc () 'd and realloc ()' d as the array grew. The array was not specified because the type of the elements was unknown. The user has to create and initialize elements, pass them to the array implementation, and keep track of what type was used.

In memory, the structure will exist either on the stack or on the heap (user choice), the elements themselves will be scattered throughout the heap, and the array of pointers to elements will exist on the heap.

The problem is that when I went for this, I needed to assign a pointer to an empty space in the array of pointers (for example, when adding an element), and I couldn't do that because void pointers cannot (the compiler says: "incomplete type "void" is not assigned ").

Is there any other approach I should be using?

Nguai's code helped me get it right! See him below in his answer, and here is the implementation I wrote based on his code:

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;
}