Understanding the '&' operator

5
votes

As of what I know about '&' operator, it returns the base address of the operand in memory.

Let us imagine the following scenario (as on my machine):

  • sizeof(int) = 4 bytes
  • sizeof(float) = 4 bytes
  • sizeof(char) = 1 byte

Now, if I write something like this:

void main() {
 int i = 5411;
 int *ip = &i;
 char *c = &i;

 printf("%d",*ip);
 printf("%c",*c);
}

The first printf() should give me 5411. Talking about the second printf(), the base address of i contains 10101001 (higher order 8 bits = 1 byte for char type pointer). Hence *c should give me 169, which when converted to %c is an invalid character.

But the compiler is giving me '#' or some other valid output. Why is it so ? Any inputs ?

EDIT (taken from the author's comment on one of the answers):

That was just a dummy case, since I was away from the actual machine.
The actual case is i = 5411

5
c++c
In any case, if you try to "print" a "char" it will be displayed as a char, not as the corresponding integer code. - Cedric H.
probably something to do with char encoding being used, I would guess. - Tony The Lion
Yeah I too agree with that. But there must be a reason for getting '#' value from the last printf(). It's not a garbage value. - Gaurav Kalra
Shouldn't it be 130 instead of 144? - kennytm
@Gaurav Kalra: actually, there is no guarantee you will get 114 as a result. You are counting on endienness (en.wikipedia.org/wiki/Endianness) to get 144, but not all systems are little endian. - André Caron

5 Answers

24
votes

You seems to have trouble understanding how integers are stored in memory. Take 5411 as example.

5411 = 1010100100011

this number 13 binary digits has however, since an int is 32-bit, it must be pad to 32 digits

5411 = 00000000 00000000 00010101 00100011

On a little endian machine (x86, ARM by default), the least significant bytes are stored in the front, so in the memory:

00100011   00010101    00000000    00000000
^
c          c + 1       c + 2       c + 3
ip

Therefore, *c should return 00100011 i.e. 35 ('#').

5
votes

ASCII only defines characters up to 127. Besides that, what you really want to do is print the numeric corresponding to the value in *c, this is also done using %d...

 printf("%d",*c);

...should display the number as you expect.

3
votes

Firstly, your program is ill-formed. Neither C nor C++ allows initializing an char * pointer with an int * value. You need an explicit cast in your initialization of c pointer.

Secondly, which byte of the original integer i - higher order or lower order - resides at its "base address" is implementation-defined. There are little-endian architectures, where the lower-order but will be seen through *c (which is has value 130 on a 8-bit char machine, not 114). And there are big-endian architectures, where the higher-order but will be seen through *c (which is 0 on a 8-bit char machine). So you should expect either character with code 130 or character with code 0 to be printed with %c format specifier.

Thirdly, in a typical implementation there's normally no such thing as "invalid character code". For any code something will usually be printed in one way or the other. I don't see though how you managed to obtain # as the output from your code. Is this the real code you were running?

1
votes

The Address of *c is that of i, because you have assigned c to &i. It will then take the highest or lowest (depends on the endian) and print that character.

1
votes

Just to learn something about the encoding of your integers you should experiment a bit and do

printf("0x%X, %X|%X|%X|%X\n", 
  i, 
  i & 0xFF,
  (i >> 8) & 0xFF
  (i >> 16) & 0xFF
  (i >> 24) & 0xFF
  );

An then do the same with c[0], c[1] etc and other format strings as %c.