{"id":33962,"date":"2023-02-17T01:12:11","date_gmt":"2023-02-16T19:42:11","guid":{"rendered":"https:\/\/jassweb.com\/solved\/solved-why-the-address-of-structure-and-next-is-not-same\/"},"modified":"2023-02-17T01:12:11","modified_gmt":"2023-02-16T19:42:11","slug":"solved-why-the-address-of-structure-and-next-is-not-same","status":"publish","type":"post","link":"https:\/\/jassweb.com\/solved\/solved-why-the-address-of-structure-and-next-is-not-same\/","title":{"rendered":"[Solved] Why the address of structure and next is not same?"},"content":{"rendered":"

[ad_1]
\n<\/p>\n

\n
\n
<\/div>\n
\n
\n

TL;DR<\/h1>\n

Your code provokes Undefined Behavior<\/em>, as already mentioned in Morlacke’s Answer. Other than that, it seems that you’re having problems on understanding how pointers work. See references for tutorials.<\/p>\n

\n

First, From your comments<\/h2>\n

When you say that there’s memory allocated for ip<\/code> in this case:<\/p>\n

int i = 10;\nint *ip;\nip = &i;\n<\/code><\/pre>\n
What happens is:<\/p>\n
    \n
  1. You declare an int<\/code> variable called i<\/code> and assign the value 10<\/code> to it. Here, the computer allocates memory for this variable<\/em> on the stack. Say, at address 0x1000<\/code>. So now, address 0x1000<\/code> has content 10<\/code>.<\/li>\n
  2. Then you declare a pointer called ip<\/code>, having type int<\/code>. The computer allocates memory for the pointer<\/em>. (This is important, see bellow for explanation). Your pointer is at address, say, 0x2000<\/code>.<\/li>\n
  3. When you assign ip = &i<\/code>, you’re assigning the address of variable i<\/code><\/strong> to variable ip<\/code>. Now the value<\/strong> of variable ip<\/code> (your pointer) is the address of i<\/code>. ip<\/code> doesn’t hold the value 10<\/code> – i<\/code> does. Think of this assignment as ip = 0x1000<\/code> (don’t actually write this code<\/em>).<\/li>\n
  4. To get the value 10<\/code> using your pointer you’d have to do *ip<\/code> – this is called dereferencing the pointer. When you do that, the computer will access the contents of the address held by the pointer<\/strong>, in this case, the computer will access the contents on the address of i<\/code>, which is 10<\/code>. Think of it as: get the contents of address 0x1000<\/code><\/strong>.<\/li>\n<\/ol>\n
    Memory looks like this after that snippet of code:<\/p>\n
    VALUE    :   10    | 0x1000 |\nVARIABLE :    i    |   ip   |\nADDRESS  :  0x1000 | 0x2000 |\n<\/code><\/pre>\n
    Pointers<\/h2>\n
    Pointers are a special type of variable in C. You can think of pointers as typed variables that hold addresses<\/strong>. The space your computer allocates on the stack for pointers depends on your architecture<\/em> – on 32bit<\/code> machines, pointers will take 4 bytes; on 64bit<\/code> machines pointers will take 8 bytes. That’s the only<\/strong> memory your computer allocates for your pointers (enough room to store an address<\/strong>).<\/p>\n
    However, pointers hold memory addresses, so you can make it point to some block of memory… Like memory blocks returned from malloc<\/a><\/strong>. <\/p>\n
    \n
    So, with this in mind, lets see your code:<\/p>\n
    NODE *hi;   \nprintf(\"\\nbefore malloc\\n\");\nprintf(\"\\naddress of node is: %p\",hi);\nprintf(\"\\naddress of next is: %p\",hi->next);\n<\/code><\/pre>\n
      \n
    1. Declare a pointer to NODE<\/code> called hi<\/code>. Lets imagine this variable hi<\/code> has address 0x1000<\/code>, and the contents of that address<\/strong> are arbitrary – you didn’t initialize it, so it can be anything from zeroes to a ThunderCat<\/a><\/strong>.<\/li>\n
    2. Then, when you print hi<\/code> in your printf<\/code> you’re printing the contents of that address 0x1000<\/code>… But you don’t know what’s in there… It could be anything.<\/li>\n
    3. Then you dereference the hi<\/code> variable. You tell the computer: access the contents of the ThunderCat<\/em> and print the value of variable next<\/code><\/strong>. Now, I don’t know if ThunderCats have variables inside of them, nor if they like to be accessed… so this is Undefined Behavior<\/em>. And it’s bad!<\/strong> <\/li>\n<\/ol>\n
      To fix that:<\/p>\n
      NODE *hi = malloc(sizeof NODE);\nprintf(\"&hi: %p\\n\", &hi);\nprintf(\" hi: %p\\n\", hi);\n<\/code><\/pre>\n
      Now you have a memory block of the size of your structure to hold some data. However, you still didn’t initialize it, so accessing the contents of it is still undefined behavior<\/em>.<\/p>\n
      To initialize it, you may do:<\/p>\n
      hi->id = 10;\nhi->next = hi;\n<\/code><\/pre>\n
      And now you may print anything you want. See this:<\/p>\n
      #include <stdio.h>\n#include <stdlib.h>\n\nstruct node {\n    int id;\n    struct node *next;\n};\n\ntypedef struct node NODE;\n\nint main(void)\n{\n    NODE *hi = malloc(sizeof(NODE));\n\n    if (!hi) return 0;\n\n    hi->id = 10;\n    hi->next = hi;\n\n    printf(\"Address of hi (&hi)   : %p\\n\", &hi);\n    printf(\"Contents of hi        : %p\\n\", hi);\n    printf(\"Address of next(&next): %p\\n\", &(hi->next));\n    printf(\"Contents of next      : %p\\n\", hi->next);\n    printf(\"Address of id         : %p\\n\", &(hi->id));\n    printf(\"Contents of id        : %d\\n\", hi->id);\n\n    free(hi);\n\n    return 0;\n}\n<\/code><\/pre>\n
      And the output:<\/p>\n
      $ .\/draft\nAddress of hi (&hi)   : 0x7fffc463cb78\nContents of hi        : 0x125b010\nAddress of next(&next): 0x125b018\nContents of next      : 0x125b010\nAddress of id         : 0x125b010\nContents of id        : 10\n<\/code><\/pre>\n
      The address of variable hi<\/code> is one, and the address to which it points to<\/strong> is another. There are several things to notice on this output:<\/p>\n
        \n
      1. hi<\/code> is on the stack. The block to which it points is on the heap.<\/li>\n
      2. The address of id<\/code> is the same as the memory block (that’s because it’s the first element of the structure). <\/li>\n
      3. The address of next<\/code> is 8 bytes from id<\/code>, when it should be only 4(after all int<\/code>s are only 4 bytes long) – this is due to memory alignment. <\/li>\n
      4. The contents of next<\/code> is the same block pointed by hi<\/code>.<\/li>\n
      5. The amount of memory “alloced” for the hi<\/code> pointer itself is 8 bytes, as I’m working on a 64bit<\/code>. That’s all the room it has and needs<\/em>.<\/li>\n
      6. Always free<\/code> after a malloc<\/code>. Avoid memory leaks<\/a><\/li>\n
      7. Never write code like this for other purposes than learning.<\/li>\n<\/ol>\n
        Note: When I say “memory alloced for the pointer” I mean the space the computer separates for it on the stack when the declaration happens after the Stack Frame<\/a> setup.<\/em><\/p>\n
        \n
        References<\/h2>\n