C Programming - Pointers - Discussion

Well done @Mayur.

@All.

According to me; the coding part is;


#include<stdio.h>

int main()
{
// create and array hear with name arr

int arr[3] = {2, 3, 4};

// assume array is created at memory location 1000
// so 2 is store at location 1000 and
// 3 on 1004 and
// 4 is store at 1008......

// created one char pointer *p
char *p;
//p is pointing to the 1000
p = arr;

p = (char*)((int*)(p));
printf("%d, ", *p);
p = (int*)(p+1); // when you increase hear p+1 then 1000 becomes 1001 because p is character pointer
printf("%d", *p);
return 0;
}

All droughts are cleared, Thanks for explaining @Puru.

It will give a warning instead of error hence p=arr is illegal but this code will compile and give output.

But my question is how to know that these integers will be stored in little-endian firm or big-endian?

Please, anyone, help me.

Just, (p+1) is NULL. (p+2) is NULL. (p+2) is NULL. (p+4) is NULL. etc
Otherwise, p=(int*)(p+1) is NULL or ZERO.

Simply p=p+1 works. No need to convert integer pointer then character pointer.

Cannot convert an integer to a character pointer.

So,to get the desired output the revised code should be p=(char*)arr in place of p=arr and p=(char*)(int*)(p+1) in place of p=(int*)(p+1) .

Can anyone explain this to get it?

The above code has displayed suspicious pointer conversion error @line p=(int*)(p+1); in turbo C.

then how it is compiled and displayed output?

Can anyone tell the memory address allocation for the above program?

Output is 0 except for { p = (int*)(p+0) }, { p = (int*)(p+4) } and { p = (int*)(p+8) }.
Per the previous question in is FOUR BYTES, so the binary saved in memory in NOT as above, but:
00000000 00000000 00000000 00000010 - first 4 bytes for 2
00000000 00000000 00000000 00000011 - second 4 bytes for 3
00000000 00000000 00000000 00000100 - third 4 bytes for 4.

The { p = (int*)(p+1); } is moving us ONLY 8 bites (one byte) at a time - AFTER STARTING with the "2" at the end of the first bytes. "p+2" carries us only 8 bits forward because of { char *p;...p = (char*)((int*)(p)); }.

Throughout p is a CHAR pointer moving only the 1 byte of a char.