Dynamic array type using void pointers C

Question

I made my own dynamic array type using void pointers. I'd like to know what you think of my implementation. void pointers are nice but I fear they may be inefficient. The compiler cannot tell what you are doing because it has no size information. Either way i like the flexibility and the fact that i do not have to use macros as much. But what are your thoughts on this? I am still working on it and am still finding some minor bugs here and there. It has been a fun project to work on.

main.c

#include "array.h"
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

void log_int(void *p);

int main(int argc, char const *argv[])
{
    /* declare an integer array. */
    int *a = array_alloc(sizeof(*a), log_int);

    array_reserve(a, 32);

    /*
        append a list 1 - 9 
        fixed functions usually take in local arrays 
            or variadic macro arguments. 
    */
    array_give_fixed(a, 1, 2, 3, 4, 5, 6, 7, 8, 9);

    /* 
        array_take usually stores the values taken 
            from an array into a buffer.
        Passing NULL causes each elelemnt taken to have 
            its destructor called.
    */
    array_take(a, NULL, 3);

    int i[2];
    /* array_take returns the number of elements taken. */
    for(; array_take_fixed(a, i); )
    {
        fprintf(stdout, "%d ", i[0]);
        fprintf(stdout, "%d\n", i[1]);
    }
    
    /*
        array_free calls each elements destructor 
            and frees the array itself. 
    */
    array_free(a);
    return 0;
}

void log_int(void *p)
{
    int *i = p;
    fprintf(stderr, "integer popped %d\n", *i);
}

array.h

#ifndef ARRAY_H
#define ARRAY_H

#include <assert.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#define COUNT(a) (sizeof(a) / sizeof *a)

typedef struct {
    void (*freeElem)(void *);
    size_t szElem;
    size_t ctElem;
    size_t cpElem;
} Array_Header;

void *array_alloc(size_t szElem, void (*freeElem)(void *));
void array_free_impl(void *a);
void *array_reserve_impl(void *a, size_t capacity);
void *array_push_impl(void *a, const void *elem);
void array_pop(void *a);
void *array_give_impl(void *a, const void *elems, size_t n);
size_t array_take(void *a, void *elems, size_t n);
size_t array_szElem(const void *a);
size_t array_ctElem(const void *a);
size_t array_cpElem(const void *a);

#define array_reserve(a, capacity) do { a = array_reserve_impl(a, capacity); } while(0)
#define array_push(a, elem) do { a = array_push_impl(a, elem); } while(0)
#define array_give(a, elems, n) do { a = array_give_impl(a, elems, n); } while(0)

#define array_give_fixed(p, ...) \
    do { \
        p = array_give_impl( \
            p, &(__typeof__(*p)[]){__VA_ARGS__}, \
            sizeof((__typeof__(*p)[]){__VA_ARGS__}) \
            / sizeof(__typeof__(*p))); \
    } while(0)

#define array_take_fixed(p, a) \
    array_take(p, a, sizeof(a) / sizeof(*a))

#define array_free(a) do { array_free_impl(a); a = NULL; } while(0)

#endif /* ARRAY_H */

array.c

#include "array.h"

void *array_alloc(size_t szElem, void (*freeElem)(void *))
{
    void *a = malloc(sizeof(Array_Header));
    Array_Header *header = a;
    header->freeElem = freeElem;
    header->szElem = szElem;
    header->ctElem = 0;
    header->cpElem = 0;
    return header + 1;
}

void array_free_impl(void *a)
{
    assert(a);
    Array_Header *header = (Array_Header *)a - 1;
    if(header->freeElem)
    {
        unsigned char *begin = a;
        unsigned char *end = begin + header->ctElem * header->szElem;
        for(; begin != end; begin += header->szElem)
        {
            header->freeElem(begin);
        }
    }
    free(header);
}

void *array_reserve_impl(void *a, size_t capacity)
{
    assert(a);
    Array_Header *header = (Array_Header *)a - 1;
    if(capacity > header->cpElem)
    {
        header->cpElem = capacity;
        header = realloc(header, sizeof(*header) + header->cpElem * header->szElem);
        a = header + 1;
        assert(header);
    }
    return header + 1;
}

void *array_push_impl(void *a, const void *elem)
{
    assert(a);
    assert(elem);
    Array_Header *header = (Array_Header *)a - 1;
    if(header->ctElem + 1 > header->cpElem)
    {
        header->cpElem = (header->cpElem + 1) * 2;
        header = realloc(header, sizeof(*header) + header->cpElem * header->szElem);
        a = header + 1;
        assert(header);
    }
    memcpy((unsigned char *)a + header->ctElem * header->szElem, elem, header->szElem);
    ++header->ctElem;
    return header + 1;
}

void array_pop(void *a)
{
    assert(a);
    Array_Header *header = (Array_Header *)a - 1;
    if(header->ctElem > 0)
    {
        --header->ctElem;
        if(header->freeElem)
        {
            unsigned char *p = (unsigned char *)a + header->ctElem * header->szElem;
            header->freeElem(p);
        }
    }
}

void *array_give_impl(void *a, const void *elems, size_t n)
{
    assert(a);
    assert(elems);
    Array_Header *header = (Array_Header *)a - 1;
    if(header->ctElem + n > header->cpElem)
    {
        header->cpElem = (header->cpElem + n) * 2;
        header = realloc(header, sizeof *header + header->cpElem * header->szElem);
        a = header + 1;
        assert(header);
    }
    memcpy((unsigned char *)a + header->ctElem * header->szElem, elems, n * header->szElem);
    header->ctElem += n;
    return header + 1;
}

size_t array_take(void *a, void *elems, size_t n)
{
    assert(a);
    Array_Header *header = (Array_Header *)a - 1;
    // if(header->ctElem >= n)
    n = n > header->ctElem ? header->ctElem : n;
    {
        header->ctElem -= n;
        if(elems)
        {
            memcpy(elems, (unsigned char *)a + header->ctElem * header->szElem, n * header->szElem);
        }
        else
        {
            unsigned char *begin = (unsigned char *)a + header->ctElem * header->szElem;
            unsigned char *end = begin + n * header->szElem;
            for(; begin != end; begin += header->szElem)
                header->freeElem(begin);
        }
    }
    return n;
}

size_t array_ctElem(const void *a)
{
    assert(a);
    Array_Header *header = (Array_Header *)a - 1;
    return header->ctElem;
}

size_t array_cpElem(const void *a)
{
    assert(a);
    Array_Header *header = (Array_Header *)a - 1;
    return header->cpElem;
}

size_t array_szElem(const void *a)
{
    assert(a);
    Array_Header *header = (Array_Header *)a - 1;
    return header->szElem;
}

```

Answer 1

Much feedback on the recent Array List C implementation applies here too.

() around macro parameters

Good practice to enclose a macro parameters with (), yet a still remain problematic. Example:

// #define array_push(a, elem) do { a = array_push_impl(a, elem); } while(0)
#define array_push(a, elem) do { a = array_push_impl((a), (elem)); } while(0)

Check allocation success

void *a = malloc(sizeof(Array_Header));
if (a == NULL) return NULL;  // add

.h file: only code necessary #include for the headers.

#include <assert.h> and perhaps others not needed in the .h file. Remove them.

Unnecessary struct

typedef struct { ... } Array_Header; not needed in the .h file. Move to the .c file.

Even better, re-define functions to use a pointer to Array_Header.

---

Array alignment

As OP wants to use header + 1 as the start of an array of any type, additional padding may be needed in Array_Header. Since *alloc() returns a pointer good for all alignments, to make certain header + 1 is also aligned for any type use a FAM of type max_align_t (which is an object type whose alignment is the greatest fundamental alignment).

typedef struct {
    void (*freeElem)(void *);
    size_t szElem;
    size_t ctElem;
    size_t cpElem;
    max_align_t a[]; // Add
} Array_Header;