I've implementated something like this in my testing scripts recently, when messing with standard C, and I got curious about it. This is no homework, its just some hobby of my own.
#include <stdio.h>
typedef struct Struct0 {
int x;
int y;
} Struct0;
typedef struct Struct1 {
char x;
double y;
char z;
} Struct1;
typedef struct Struct2 {
double x;
char y;
int z;
char w;
} Struct2;
void my_test_callback(void *pack) {
// Type cast back to void**
void **params = (void **) pack;
// Unpack data
Struct0* s0 = (Struct0 *) params[0];
Struct1* s1 = (Struct1 *) params[1];
Struct2* s2 = (Struct2 *) params[2];
// Use the data
printf("s0: %i %i\n", s0->x, s0->y);
printf("s1: %c %.2f %c\n", s1->x, s1->y, s1->z);
printf("s2: %.2f %c %i %c\n", s2->x, s2->y, s2->z, s2->w);
}
int main(int argc, char **argv) {
// Imagine we have two or more variables that need to be passed
// to a single function call, as a single parameter.
Struct0 a;
Struct1 b;
Struct2 c;
// Initializing Struct 0
a.x = 1;
a.y = 2;
// Initializing Struct 1
b.x = 'a';
b.y = 3.0;
b.z = 'b';
// Initializing Struct 2
c.x = 4.0;
c.y = 'c';
c.z = 5;
c.w = 'd';
// So, instead of doing something like this (which is the common way):
struct packed {
Struct0 _a;
Struct1 _b;
Struct2 _c;
} pack_data;
pack_data._a = a;
pack_data._b = b;
pack_data._c = c;
// I would like to do something much more generic, such as:
void* generic_pack[3];
generic_pack[0] = (void *) &a; // This way, I don't really need to
generic_pack[1] = (void *) &b; // know the variables types, and I
generic_pack[2] = (void *) &c; // can simply type cast them to void*
// Is it legal to do this? Will it always work?
my_test_callback((void *) generic_pack);
// Output from my console:
// s0: 1 2
// s1: a 3.00 b
// s2: 4.00 c 5 d
return 0;
}
The code compiles with no problems, created and tested on windows 10, gcc.exe (Rev6, Built by MSYS2 project) 12.2.0 , and it works without any segmentation faults.
Will converting gen_pack (which is a void ** pointer) to a void * type be always guaranteed to work everytime we run the script? Or did we just got lucky a segmentation fault never occured?
The conversion itself is OK as far as C goes. C allows pretty much any form of wild and crazy pointer conversions - and in case of void* specifically, they can be carried out without casting. The problems only start to appear when you de-reference the pointer through the wrong type.
generic_pack[0] = (void *) &a; This is OK and you don't even need the cast.
my_test_callback((void *) generic_pack); This is fishy but the cast itself is valid. What you are doing here is converting a "decayed" array pointer (decayed from void* [3] to void**) into a void*. And again, you don't need the cast when converting to void*.
void **params = (void **) pack; Since the caller coded had array decay, this is ok. But again we don't need the cast.
If the caller code had been (void *) &generic_pack then it would be wrong and problematic.
Similarly, had you declared the parameter as void* pack[3] then the parameter would have "decayed" into a void** and there would be no problems either.
Struct0* s0 = (Struct0 *) params[0]; You de-reference a void** and perform pointer arithmetic on it. It is pointing at an array of void* so it is ok. But again, no need to cast.
Other than that, it is fine to cast a member of a void* [3] array into a struct pointer, since that's what you stored there in the first place.
Note that not declaring the void* array as a middle step would have been much more problematic in case you decided to point at a struct array with a void**. Because only the void* is the special generic pointer type, it does not apply to void**.
The summary of this is that void* are unsafe and dangerous, so it is wise to avoid them. The correct way to implement your code would have been to invent a 4th struct containing the 3 others:
typedef struct
{
Struct0 s0;
Struct1 s1;
Struct2 s2;
} everything;
void my_test_callback(const everything* pack)
Or alternatively that struct could have contained pointers to structs allocated elsewhere. The best option by far would of course have been to rewrite the function to accept 3 parameters.