在结构内部对结构指针进行Void指针而不取消引用它

Question

Let's imagine I have 3 different types of datasets in 3 different structs:

typedef struct
{
    int a;
    //...
}DATATYPE1;

typedef struct
{
    int a;
    //...
}DATATYPE2;

typedef struct
{
    int a;
    //...
}DATATYPE3;

Then imagine I want one of those types of data to be assigned to a main struct like this:

typedef struct
{
    int b;
    void* data;
    //...
}OBJECT;

Say I declare OBJECT* abc = malloc(sizeof(OBJECT)); and DATATYPE1* dt1 = malloc(sizeof(DATATYPE1)); Is there a way I could then cast in the code something like this:

abc->data = dt1;

and then call:

(abc->data)->a;

without dereferencing the abc->data pointer back to eg DATATYPE1* dp = abc->data and then use dp->a;

Answer 1

I assume that the problem is that you want to access the a field of your three DATATYPE S, without knowing which DATATYPE is actually present. The answer, is yes you can, because the C specification explicitly says that whatever DATATYPE is present, the pointer points at the first member of the structure, and hence can be safely cast to that type.

See: Are there any guarantees about C struct order? and especially:

15 Within a structure object, the non-bit-field members and the units in which bit-fields reside have addresses that increase in the order in which they are declared. A pointer to a structure object, suitably converted, points to its initial member (or if that member is a bit-field, then to the unit in which it resides), and vice versa. There may be unnamed padding within a structure object, but not at its beginning.

Hence, the following code allows you to access a:

OBJECT* abc = malloc(sizeof(OBJECT));
abc->data = malloc(sizeof(DATATYPE1));
int* pointerToA = (int*) abc->data;

Whether this is good programming practice is another question, that I will not answer.

Answer 2

You need to declare everything that you will make reference in your C code. This is the only way to the compiler knows the size and location of the object in that specific address.

I think you can use anonymous union blocks and do something like this:

typedef struct
{
    int b;
    union {
       void* data;
       DATATYPE1 *dt1;
       DATATYPE2 *dt2:
       DATATYPE3 *dt3;
    };    
} OBJECT;

then use :

OBJECT* abc = (OBJECT*)malloc(sizeof(OBJECT));
DATATYPE1* dt1 = (DATATYPE1*)malloc(sizeof(DATATYPE1));
abc->data = (void *)dt1;
int val = abc->dt1->a;