pulsar17's blog

Thing #1 : Object = storage + type

Think of the memory in your computer as a sequence of raw bits, with no inherent meaning.

To expand on the above example [1] :

           ┌────────────────────────────────┐
  x  -->   │00000000000000000000000000000101│
  |        └────────────────────────────────┘
┌───┐
│int│
└───┘
         Same memory view but a little zommed in

What gives meaning to these bits is the type of the object. And this type is not set in stone, it depends on the variable you are using to reference this object.

It's as if the variable stamped its type on the object:

           ┌────────────────────────────────┐
  x  -->   │00000000000000000000000000000101│
  |        └────────────────────────────────┘
┌───┐                    ∘---∘
│int│                    |int|
└───┘                    ∘---∘

Now, normally you wouldn't want to change the type of an object like I am going to do now. An int is supposed to be accessed as an int. C being the tool it is, allows you to shoot yourself in the foot and then let you drown in the shame of your incompetence. You can do this for example:

#include <stdio.h>

 int main(){
     long val = 478560413032L;
     char *c = &val;
     for (int i = 0; i < sizeof(long); i++, c++){
         printf("%c\n", *c);
     }
 }

The above code accessed an object that was supposed to be accessed as long int like a char array.

On my system [1] [2] this code prints (↵ indicates a newline):

h↵
e↵
l↵
l↵
o↵
↵
↵
↵

You are accessing the same object - the same underlying storage - but you are interpreting it differently based on the type of the variable you are using to reference it.

This is different from a type cast:

#include <stdio.h>

 int main(){
     int x = 5;
     float f = x; // An implicit type cast
     printf("%d, %f\n", x, f);
 }

In this code, we are not sharing the same underlying object. For the float variable f, c creates a new object whose internal representation is apt for that type. In this case a copy of 5 would be converted to the IEEE 754 format for floating-point and stored in a new object just for f.

To drive home this fact, we go back to our earlier example:

           ┌────────────────────────────────┐
  x  -->   │00000000000000000000000000000101│ = 5
  |        └────────────────────────────────┘
┌───┐
│int│
└───┘

If we just copied the value as is and just slapped on the type float onto f, the situation would look like:

           ┌────────────────────────────────┐
  f  -->   │00000000000000000000000000000101│ = 7.00649232162e-45 !!! Not what you want
  |        └────────────────────────────────┘
┌─────┐
│float│
└─────┘

This is wrong, very wrong ❌

The reason for this is that int s and float s are stored differently internally.

What you actually want is this:

           ┌────────────────────────────────┐
  f  -->   │01000000101000000000000000000000│ = 5 ✅
  |        └────────────────────────────────┘
┌─────┐
│float│
└─────┘

You need that conversion from int to float. c does that for you.