Casting dynamically allocated int pointer to struct pointer

Question

I saw code as written below.

typedef struct abc {
    int a;
    char b;
    float c;
} abc;

int main()
{
  abc *ab;
  int *i;
  i = (int*)malloc(sizeof(int));
  *i = 0;
  ab = (abc*) i;

  return 0;
}

In the penultimate line ab = (abc*) i;, what does the code try to do?

If we want to set the value of ab->a, then why is it done in this way, rather than:

ab->a = (int)i;

If ab = (abc*) i; updates the value of ab->a, then how will the other two structure members get initialized without intitializing them exclusively?

Answer 1

then how other two structure members will get initialized without intitializing them exclusively?

They won't.

You'd be getting garbage values in ab->b and ab->c because i does not represent a chunk of memory of a sufficient size to represent an instance of abc.

ab->a is equal to 0 because when you did: *i = 0, you stored the value 0 in the memory location that i pointed to. When you made abc point to the same memory location as i, no writes were done to memory, you just changed the position of the data.

Since 0 was previously stored in 4 bytes at the position that i pointed to, and since int ab::a happens to take up 4 bytes and also happens to be the first member of the struct, ab->a will be equal to 0.

In memory, relative to the position of the instance, your struct is ordered like this:

 ____ ____ ____ ____    ____    ____ ____ ____ ____
| 00 | 01 | 02 | 03 |  | 04 |  | 05 | 06 | 07 | 08 |
|____|____|____|____|  |____|  |____|____|____|____|
        int a          char b         float c

I hope this clears things up.

Note
You're not really guaranteed to have the struct completely packed up like I made it seem in the above representation. While order will be conserved, the space between consecutive members is not always going to be 0 memory address units. Read up on Alignment.

Answer 2

The line ab = (abc*) i; is casting the pointer variable i of type int* to type abc*, and making that assignment to pointer variable ab. This is certainly not how you want to go about initializing the data members in the struct, though, particularly because only enough room for an int was allocated and we're using a struct that takes up significantly more space than an int.

At the end of the day, it's legal code but very scary. I'm not even sure you can be guaranteed to have data member int a stored in the address pointed to by ab. I want to say it's implementation dependent, but maybe somebody else can clear that up for me.

Answer 3

That penultimate line causes a conversion from (int *) to (abc *), and an assignment of the result to ab. It's not a very good line of code, because the old pointed-to type is smaller in size than the new pointed-to type; Some attempts to use the result of this conversion will be undefined behaviour. Leaving it as an (int *), or declaring a prefix struct to convert to would be a far better idea.

The * in abc * indicates that the type is a "pointer to abc". ab doesn't point to an abc object until you tell it to point to one. ab = /* something */ assigns ab to point to something. ab = malloc(sizeof *ab); would make sense, in this example.

This is silly: i = (int*)malloc(sizeof(int));. You don't need to cast the return value of malloc. The only justifiable reason for this is that the author of this code has neglected to #include <stdlib.h>. I suggest including that library, rather than casting the return value. You can feel free to ignore my advice, but don't ask any questions about strange errors until you've read this page.

Answer 4

abc *ab; ab is a pointer of type struct abc; int *i; is a pointer to the int returned by malloc

It's value is set using *i = 0;

ab = (abc*) i;

This line is assigning the address of location allocated by malloc to ab. By typecasting i to (abc*) it is indicated that ab will be used to read memory chunks of the size of struct abc ab = (abc*) i; does not assign value to a. To assign value to a u will do ab->a = 5;

The values already present are garbage values (default random value)

Answer 5

ab = (abc*) i; updates the value of ab->a

If we look at struct layout, int is int is first member, so it will be initialize with 0, so ans is yes! I tried with VC and it initialize it with 0, but this is tricky, in case of struct if member change order then you got grabage!

There is also memory leak, memory allocated with malloc never freed!