C dynamic array and pointers

Question

I've written an implementation of a dynamic array in C, but I'm not sure if my implementation is correct... This is what I'm worried about: if I add an element, will it remain in the collection? This problem has arisen from my (apparently) limited knowledge on void pointers. I haven't found any answers to my question online...

The List struct is defined like this:

typedef struct list
{
    /**
     * C-style array containing the data in this list.
     */
    void** data;
    /**
     * Amount of elements currently present in this list.
     */
    unsigned int size;
    /**
     * Amount of elements that could be present in this list (i.e. size + number of empty spots).
     */
    unsigned int capacity;
} List;

So far so good?

Now, when I want to add an element to a list l, I call List_Add(&l, &element)...

void List_Add(List* list, void* element)
{
    if (list->data == NULL)
    {
        return;
    }

    if (list->size == list->capacity)
    {
        // Double the data array of list.
        list->data = realloc(list->data, 2 * list->capacity * sizeof(void*));
        list->capacity *= 2;
    }

    if (list->data != NULL)
    {
        list->data[list->size] = element;
        ++(list->size);
    }
}

By the way: yes, list->data is malloced before calling this function.

I've done some testing with adding elements, but I'm not sure if it's entirely correct. If I were to call this function with an element created on the stack (example below), would it continue to work for the entirety of the program's lifetime?

Example

List l;
List_Init(&l);
int i = 1;
List_Add(&l, &i);

Answer 1

If I were to call this function with an element created on the stack (example below), would it continue to work for the entirety of the program's lifetime?

No, it wouldn't:

• i is created on the stack
• pointer to i is saved in the list
• i disappears and stack is reused when caller goes out of scope (now list is pointing to garbage)

Your List can be used to store:

• Objects created on the heap (using malloc)
• Global/static objects
• Local stack objects, but only if they are removed again before they go out of scope.

For example:

List l;
List_Init(&l);
int i = 1;
int* ptr_i = (int*)malloc(sizof(int));
*ptr_i = i;
List_Add(&l, ptr_i);
// *ptr_i will remain until someone calls free(ptr_i)