Dereferencing this pointer gives me -46, but I am not sure why

by

If you have something like , 

int x = 1234;
int *p = &x;

If You Dereference Pointer p then it will correctly read integer bytes. Because You declared it to be pointer to int . It will know how many bytes to read by sizeof() operator. Generally size of int is 4 bytes (for 32/64-bit platforms) but it is machine dependent that is why it will use sizeof() operator to know correct size and will read so.

For Your Code

 int y = 1234;
 char *p = &y;
 int *j  = &y;

Now pointer p points to y but we have declared it to be pointer to a char so it will only read one byte or whatever byte char is of .
1234 in binary would be represented as

        00000000 00000000 00000100 11010010

Now if your machine is little endian it will store the bytes reversing them

        11010010 00000100 00000000 00000000

11010010 is at address 00 Hypothetical address, 00000100 is at address 01 and so on. 

BE:      00   01   02   03
       +----+----+----+----+   
    y: | 00 | 00 | 04 | d2 |
       +----+----+----+----+


LE:      00   01   02   03
       +----+----+----+----+
    y: | d2 | 04 | 00 | 00 |
       +----+----+----+----+

(In Hexadecimal)

So now if you dereference pointer p it will read only first byte and output will be (-46in case of signed char and 210 in case of unsigned char, according to the C standard the signed-ness of plain char is “implementation defined.) as Byte read would be 11010010(because we pointed signed char(in this case it is signed char).

On your PC negative numbers are represented as 2’s Complement so the most-significant bit is the sign bit. First bit 1 denotes the sign. 11010010 = –128 + 64 + 16 + 2 = –46 and if you dereference pointer j it will completely read all bytes of int as we declared it to be pointer to int and output will be 1234

If you declare pointer j as int *j then *j will read sizeof(int) here 4 bytes(machine dependent). Same goes with char or any other data type the pointer pointed to them will read as many bytes there size is of , char is of 1 byte.

As others have pointed, you need to explicitly cast to char* as char *p = &y; is a constraint violation – char * and int * are not compatible types, instead write char *p = (char *)&y.

More Related Contents:

  1. what is meant by (void *) variable and (void *) & variable in C [closed]
  2. “Pointer from integer/integer from pointer without a cast” issues
  3. printf(“%p”) and casting to (void *)
  4. Should I explicitly cast malloc()’s return value? [duplicate]
  5. Why does the arrow (->) operator in C exist?
  6. Meaning of “referencing” and “dereferencing” in C
  7. Pointer Arithmetic: ++*ptr or *ptr++?
  8. casting char[][] to char** causes segfault?
  9. Mis-aligned pointers on x86
  10. Casting a pointer does not produce an lvalue. Why?
  11. Why can’t I treat an array like a pointer in C?
  12. What are the rules for casting pointers in C?
  13. Difference between dereferencing pointer and accessing array elements
  14. Difference between pointer to pointer and pointer to array?
  15. Pointers program
  16. Length of array in function argument
  17. Are all data pointers the same size in one platform for all data types? [duplicate]
  18. Why can’t I convert ‘char**’ to a ‘const char* const*’ in C?
  19. How to printf a memory address in C
  20. Why can I change a local const variable through pointer casts but not a global one in C?
  21. Segmentation Fault when writing to a string [duplicate]
  22. Why is a point-to-volatile pointer, like “volatile int * p”, useful?
  23. Casting one struct pointer to another – C
  24. Weird Behaviour with const_cast [duplicate]
  25. Swap nodes in a singly-linked list
  26. When an int is cast to a short and truncated, how is the new value determined?
  27. Can I treat a struct like an array?
  28. lvalue required as increment operand
  29. pointer default value .?
  30. pow() cast to integer, unexpected result

Leave a Comment