Why is the output 2,0 instead of 2,3? - c

Question

#include<stdio.h>
int main()
{
int arr[3] = {2, 3, 4};
char *p;
p = arr;
p = (char*)((int*)(p));
printf("%d, ", *p);
p = (int*)(p+1);
printf("%d", *p);
return 0;
}
Isn't p = (int*)(p+1) ; pointing to the next element of the array? (viz 3?) So the output should be 2,3. But the output is 2,0. Why?

Answer 1

You are increasing the char pointer p to the next char memory position - that is one of the 0 padding bytes for the number 2, which, being an int takes 4 memory positions (the other 3 filled up with zeros).
In short, just replace char *p; for int *p; and get rid of all the casting at p = (char*)((int*)(p)); - your program should just work.
(To make it working keeping the not-useful casting, change p = (int*)(p+1); for p = (char *) (((int *) p) + 1); so that the increment happens on an integer pointer, not on a char pointer)
In a little-endian memory model, such as used in current PC´s, int numbers each take 4 bytes in memory - the first one being the least significative (so, for numbers smaller than 256 (2 ^ 8), they contain the whole number).
You have in memory, this byte sequence: '02 00 00 00 03 00 00 00 04 00 00 00'
When you use a "char *" pointer, the compiler knows that the size of the char data element is 1 byte. On increasing it, it just proceeds to the neighbouring byte, which is "0".
On the "printf" call, you access the content at "char * p", which is a single byte number - 0, and the compiler pads that value in the call to "printf", so that the function still sees "0" - but in other compielrs and systems, it could print garbage or segfault, since 3 of the bytes expected by the printf's "%d" parameter would not be there.

Answer 2

That's because p is the wrong kind of pointer for the datatype.
When you increment p, it doesn't increase its value by 1 * sizeof(int), it increases it by 1 * sizeof(char).
The contents of arr at the byte level, assuming an int is 4 bytes and little endian byte ordering is:
2 0 0 0 3 0 0 0 4 0 0 0
When p is first set, you have this:
2 0 0 0 3 0 0 0 4 0 0 0
^------ p
When you set p to (int*)(p + 1), you increment p by only 1. The cast doesn't help you here. So you get this:
2 0 0 0 3 0 0 0 4 0 0 0
^------ p
So dereferencing p reads 1 byte at that memory location, so you have 0.
If you wanted to increment p by the size of an int, you need to cast p itself, then add to it:
p = `(int*)(p) + 1`
Then you'll get the result you expect.

Answer 3

This is why type of pointer should be of the same data type as of the data it's pointing to for the sake of Pointer Arithmatics
adding 1 to a pointer of specific data type will add number of bytes to the memory address to which a pointer is currently pointing and now it will be pointing to the p+(x-bytes) address and de referencing it will give you the value at that address
for example
you declare a pointer of type int like
int *p = new int[5];
each element in array(if you populate the array) will be stored in memory with the space of 4 bytes (in address terms and in case of 32bit systems) in memory.
And adding 1 to pointer like p = p+1 will take you to the next element in array which is at 4 byte's address ahead of it.
same is the case for any other type of pointer just with the difference that it will be jumping to that much bytes in address space as of the data type the pointer itself it.
now you can say pointer are just pointing to memory so it should not make any difference whether we declare any type of pointer. Yes that's true but not recommended any time as when you're using pointers , pointer arithmatic is very certain to be used there. For the sake of exact jumps in memory addresses we declare pointers of the same data type as of the data they are pointing to