test void pointer before cast (instanceof)

[jeanluca]

Hi All

I've written the following test program

#include <stdio.h>

int main(void) {
  char *c = "boss" ;
  void * d = (void *)c ;

  int *e ;
  e = (int *)d ;
  printf("%d char=%d int=%d\n", e, sizeof(char), sizeof(int)) ;
}

It prints: 8183 char=1 int=4

What does 8183 mean. It seems that the 4 chars fit into one int, so I would guess there might be a relation between 8183 and "boss". Can this cast be useful ?

But what if you don't know the original type of a void pointer, is there a way to determine it?

Thnx a lot!
LuCa

[tabstop]

8183 is (apparently) the memory address where your read-only (probably) string was stored, printed as though it were an integer.

[dwks]

But what if you don't know the original type of a void pointer, is there a way to determine it?

Not really. I suppose you could look at the memory address and get some idea of the alignment of whatever it is you're pointing at, but all that will let you do is guess. With a void* pointer, all you have is a memory address. That's it.

What does 8183 mean.

I suppose it's the value stored in e, which is the value in d, which was the value in c. This, in the end, is the location in memory of the string literal "boss". Note that string literals are embedded directly in the executable, which is why "8183" is such a low number (executables are loaded into low memory). If it was the address of a variable, e.g.

int x;
printf("%p\n", &x);  /* %p -> print a pointer address, sort of like %x */);

then you'd probably get a much higher number.

[matsp]

The low number is probably because the original poster is using some ancient 16-bit compiler like Turbo C.

--
Mats

[dwks]

You're probably right.

I assumed it was due to the text/whatever section being located in low memory, but that doesn't seem to be the case with my test code. The Turbo C explanation makes more sense. [edit] Notice the (void*) cast, too . . . . [/edit]

[jeanluca]

My compiler:

$ gcc --version
i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5465)
Copyright (C) 2005 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Not really. I suppose you could look at the memory address and get some idea of the alignment of whatever it is you're pointing at, but all that will let you do is guess. With a void* pointer, all you have is a memory address. That's it.

What does that mean: the alignment of whatever it is you're pointing at ?
Can you give an example or a link to documentation ?

LuCa

[matsp]

Alignment is what byte boundary the address matches. An odd address has an alignment of 1, if the address is even, it has at least 2 as alignment. Integers will naturally be aligned at 4 byte boundaries. A 64-bit integer or a double float will align to a 8 byte boundary, etc.

But just because something is aligned to 8 bytes doesn't MEAN that it is a double. In fact, it's perfectly possible in some architectures to store data unaligned - it just means that the processor will have to do extra work to read the data from memory.

There is really no way to know from the address itself (which is what a void * contains) what the data is. Only whatever created the data knows what it actually represents. I may for example store 0x3F800000 in an integer. But print it as a floating point value and it becomes 1.0 - so it looks like a plausible floating point number.

--
Mats

[jeanluca]

OK, thnx!