Array of struct and sizeof

Question

I want to write, in C (no particolar flavour, lets say c11) a generic, global const array of struct, like the following pseudocode:

void * generic[] ={&(struct a va),&(struct b vb)};

Now I want to create a function that, given the id of the position of desired struct (I'm planning to use a const for every id, hardcoded), will copy it.

Because that copy() also is generic (accepts a void * as destination) it would need to know the strict size, witch may be specified by caller (a lot of error prone, he already need to provide the target structure and the right id) or i will also maintain a parallel array of correct sizeof for every structure.

Is there a way to automate at compile time the initialization of sizeof array? Or even implement some sort of trick to let the user specify just pass the pointer to struct without its id, without having to write a specialized get_struct_x()?

No dynamic allocation (alloc(), local variable are fine) allowed, all struct and generic array content is known at compile time.

Sorry for my bad explanation, feel free to improve/correct it.

Edit for clarification: i need to deep copy a know struct type from an array where there are stored many struct type, but the same type never repeat itself. And I need to do it from a generic get function witch will be called from different thread, so before and after the copy will lock a mutex, and I want to keep all the locking and casting code in one point, to minimize debug and create more effective test.

Answer 1

Without having to modify the underlying data structures, this is the only method I can see where this will be fairly manageable. Each entry in your array is not a void*, but rather a struct that contains an void* (to the element) and a size_t (sizeof data for that element):

#include <stdio.h>
#include <stdlib.h>

typedef struct Entry
{
    size_t len;
    void const *elem;
} Entry;

#define ELEM_ENTRY(x)   { sizeof(x), &(x) }

struct A
{
    int a1;
    long a2;
} a;

struct B
{
    float b1;
    char b2[6];
} b;

struct C
{
    unsigned int c1;
    double c2[5];
} c;

Entry generic[] =
{
    ELEM_ENTRY(a),
    ELEM_ENTRY(b),
    ELEM_ENTRY(c)
};
size_t generic_n = sizeof(generic)/sizeof(*generic);


int main()
{
    for (size_t i=0; i<generic_n; ++i)
        printf("[%zu] = %zu\n", i, generic[i].len);
}

Output

[0] = 8
[1] = 12
[2] = 44

I think that's what you're trying to do. if not, I'll drop this answer. Note that this will likely not work how you want it to if the element is a pointer type (but it will work how you want it to if it is a native array type). So be careful.