dereferencing struct pointer to structure variable

Question

I am having a little bit of confusion about derefrencing a structure pointer to a structure variable.

It will be good if I demonstrate my problem with an example.

So here I am:

struct my_struct{
    int num1;
    int num2;
}tmp_struct;

void Display_struct(void * dest_var){

    struct my_struct struct_ptr;

    struct_ptr = *((struct my_struct *)dest_var);

    printf("%d\t%d\n",struct_ptr.num1,struct_ptr.num2);

}

int main()
{
    tmp_struct.num1 = 100;
    tmp_struct.num2 = 150;


    Display_struct(&tmp_struct);
    return 0;
}

Now when I am running this example I am able to get the code to be compiled in a very clean manner and also the output is correct.

But what I am not able to get is that is this a correct way of dereferencing the structure pointer to a structure variable as we do in case of other simple data types like this:

int example_num;

void Display_struct(void * dest_var){

    int example_num_ptr;

    example_num_ptr = *((int *)dest_var);

    printf("%d\t%d\n",struct_ptr.num1,struct_ptr.num2);
}

int main()
{
    example_num = 100;


    Display_struct(&example_num);
    return 0;
}

Here we can dereference the int pointer to int variable as it is a simple data type but in my opinion we can't just dereference the structure pointer in similar manner to a structure variable as it is not simple data type but a complex data type or data structure.

Please help me in resolving the concept behind this.

Answer 1

The only problem is that you have to guarantee that the passed void* points to a variable of the correct struct type. As long as it does, everything will work fine.

The question is why you would use a void pointer and not the expected struct, but I assume this function is part of some generic programming setup, otherwise it wouldn't make sense to use void pointers.

However, if you would attempt something "hackish" like this:

int arr[2] = {100, 150};
Display_struct(arr);  // BAD

Then there are no longer any guarantees: the above code will compile just fine but it invokes undefined behavior and therefore may crash & burn. The struct may contain padding bytes at any place and the code also breaks the "strict aliasing" rules of C.

(Aliasing refers to the rules stated by the C standard chapter 6.5 Expressions, 7§)

Answer 2

You are thinking up a problem where there isn't any. A struct -type (alias an aggregate data type) is technically not very different from any other type.

If we look at things on the lower level, a variable of any type (including a struct type) is just some number of bits in memory.

The type determines the number of bits in a variable and their interpretation.

Effectively, whether you dereference a pointer-to- int or a pointer-to- struct , you just get the chunk of bits your pointer points to.

Answer 3

In your main function, you have struct tmp_struct . It is not a pointer. But it is fine, because you pass address of tmp_struct to the function void Display_struct(void * dest_var) .

Then function take the input argument, your pointer(void*). It hold the address of 'tmp_struct`.

Then inside the function you are de-referencing correctly.

struct_ptr = *((struct my_struct *)dest_var);

you deference void* to struct my_struct type. Your de-referencing correct, because you pass same type object. Otherwise it will cause run time issues.

No matter how complex your data type or data structure, de-referencing should work fine.

But if input arg type is void* make sure to pass struct my_struct to function.