Как освободить память при приведении типа из указателя void в C

Вопрос: если у меня есть указатель на структуру “ints”, как показано ниже, и я привожу его к типу void, а затем обратно, значит ли это, что я больше не могу освободить ее? Как функция free отслеживает размеры выделенной памяти?

typedef struct ints
{
    int size;              
    int *data;       
}
ints;

static void dev_array_cleanup(void *array, array_type type)
{
    switch(type)
    {
        case INT: 
        ints *i = (ints*) array; 
        free(i->data);
        free(i); 
        i = NULL; 
        break;
    }
}

static void* dev_array_set(void *array, int size, array_type type)
{
    void *p;

    switch(type) 
    {
        case INT: 
            ints *i = (ints*) malloc(sizeof(ints));
            i->size = size; 
            i->data = (int*) malloc(size * sizeof(int)); 
            p = (void*) i;
            break;
    }

    return p;
}

Я больше не могу освободить ее?

Да, вы можете освободить ее. На самом деле, вы должны (в какой-то момент) освободить ее, чтобы избежать утечки памяти.

free не заботится о типе, на который указывает указатель – он принимает void*.
И любой указатель можно преобразовать в void*.
Поэтому вы можете просто вызвать free на указателе (с приведением типа или без).

Как функция free отслеживает размеры выделенной памяти?

Еще несколько замечаний о стиле и лучших практиках, поскольку wohlstad напрямую ответил на вопрос.

• Вы должны проверять возвращаемое значение malloc и обрабатывать его, если оно не успешно.
• p как переменная и не нужна, и опасно неинициализирована, если type не INT.

static void* dev_array_set(void *array, int size, array_type type)
{
    switch(type) 
    {
        case INT: 
            ints *i = malloc(sizeof(ints));
            // Если malloc не удался, верните NULL, чтобы указать на это.
            // Вызывающий функцию dev_array_set может проверить это, чтобы знать, завершилась ли функция успешно.
            if (!i) { return NULL; }

            i->size = size; 
            i->data = malloc(size * sizeof(int));
            // Теперь мы на этапе, когда структура была выделена,
            // но массив данных еще нет. Мы должны освободить структуру 
            // немедленно и вернуть NULL, чтобы указать на ошибку.
            if (!i->data) {
                free(i);
                return NULL;
            } 
            return i;
    }

    return NULL;
}

Идея массива с прикрепленным размером не особенно идиоматична в C. Где это имеет смысл, так это в реализации чего-то вроде std::vector в C++ или ArrayList в Java: расширяемый массив с свойствами доступа за постоянное время.

И с помощью указателей void и осторожно применяемых преобразований это могло бы быть сделано достаточно универсальным.

Очень неполная реализация для демонстрации:

typedef struct {
    size_t cap;
    size_t sz;
    size_t elem_sz;
    void *arr;
} vec_t;

vec_t *vec_new(size_t element_sz, size_t init_cap) {
    vec_t *v = malloc(sizeof(*v));
    if (!v) { return NULL; }

    v->cap = init_cap;
    v->sz = 0;
    v->elem_sz = element_sz;

    v->arr = malloc(v->elem_sz * v->cap);
    if (!v->arr) {
        free(v);
        return NULL;
    }

    return v;
}

vec_t *vec_grow(vec_t *v) {
    if (!v || !v->arr) return v;

    void *new_arr = realloc(v->arr, v->elem_sz * v->cap * 2);
    if (!new_arr) { return NULL; }

    v->arr = new_arr;
    v->cap *= 2;

    return v;
}

void *vec_at(vec_t *v, size_t idx) {
    if (!v || !v->arr) { return NULL; }

    return (void *)((char *)v->arr + v->elem_sz * idx);
}

int main(void) {
    vec_t *v = vec_new(sizeof(int), 4);
    vec_grow(v);

    *(int *)((char *)v->arr + sizeof(int) * 2) = 42;

    printf("%d\n", *(int *)vec_at(v, 2));
}