c char到int指针

Question

#include<stdio.h>

int main(void)    
{
    int arr[3] = {2, 3, 4};
    char *p;
    p = (char*)arr;
    printf("%d", *(int*)(p+1));
    return 0;
}

I was doing this question on pointer. I expected output to be some garbage value since casting from char* to int* but the output always comes out to be 50331648 which is strange. Please explain

EDIT: I read this output problem on some website so need output according to given instructions

Answer 1

What you are doing is undefined behavior.

Assuming sizeof(int) is 4

Little endian system

In a little endian system, the memory layout for arr is:

arr
+----+----+----+----+----+----+----+----+----+----+----+----+
| 02 | 00 | 00 | 00 | 03 | 00 | 00 | 00 | 04 | 00 | 00 | 00 |
+----+----+----+----+----+----+----+----+----+----+----+----+

When you use:

char* p = arr;

p    p+1
|    |
v    v
+----+----+----+----+----+----+----+----+----+----+----+----+
| 02 | 00 | 00 | 00 | 03 | 00 | 00 | 00 | 04 | 00 | 00 | 00 |
+----+----+----+----+----+----+----+----+----+----+----+----+

If you interpret p+1 as an int* , and evaluate the object at that location as an int , you get:

+----+----+----+----+
| 00 | 00 | 00 | 03 |
+----+----+----+----+

In a little endian system, that number is

0x03000000

which is equal to 50331648 , which is the output you get.

Big endian system

In a big endian system, the memory layout for arr is:

arr
+----+----+----+----+----+----+----+----+----+----+----+----+
| 00 | 00 | 00 | 02 | 00 | 00 | 00 | 03 | 00 | 00 | 00 | 04 |
+----+----+----+----+----+----+----+----+----+----+----+----+

the number you will get when evaluating *(int*)(p+1) is:

+----+----+----+----+
| 00 | 00 | 02 | 00 |
+----+----+----+----+

That is equal to 0x0200 , ie 512.

It should be obvious why the operation you are performing is undefined behavior.

Answer 2

You declared arr as int and p as char . Your program will not compile using a modern compiler. What you try there is to assign different types of pointers which is wrong with that approach.

I think this is what you need:

#include<stdio.h>

int main(void)    {
    int arr[3] = {2, 3, 4};
    char *p;
    p = (char*)arr;
    printf("%d", *(int*)(p+1));
    return 0;
}

Output (garbage):

50331648

Answer 3

Here is a line by line explanation of your code and finally explain why you're getting that output

//assuming 32-bit machine 
int arr[3] = {2, 3, 4}; //arr is a pointer to the first element which is an int 2 with a memory size of 4 bytes (int = 4 bytes)
char *p; //p is declared a pointer to a char implying it points to a 1 byte memory size (char = 1 byte)
p = (char*)arr; /* p now points to the first element of the array but actually this happens by luck. 
                  here is why: (char*)arr will attempt to cast the int pointer to a char pointer, 
                  in other words, asking it to present whatever took 4bytes to be presented in 1 byte 
                  which will overwrite the least significant bytes. but since numbers are stored in reverse order, 
                  it will overwrite only zeros causing no problem.*/
printf("%d", *(int*)(p+1)); /* p is still a char pointer holding memory address of 2 in the array. 
                            casting that to int* will add extra bytes from memory. so finally what you're getting is 
                            garbage number which I think is the virtual memory limit, (48 Gb *1024 *1024 = 50331648 Kb)*/