Say a function takes a void pointer as an argument, like so: int func(void *p);
How can we determine or guess the type of what p is pointing to?
views:
249answers:
3
+11
A:
In general, you can't. In some cases, if there is a guarantee on what p points to, you may be able to look at the contents at and after that address to find out. Generally, your function should know what it's being passed, unless it just passes it along.
Data and function arguments in C are just a bunch of bits lumped together. Unless you use some of those bits to tell you what the bits are, there's no consistent way to identify it.
WhirlWind
2010-04-09 02:58:06
Voting this up... you know because you have made sure of the types in the rest of your program. If that sounds fragile it is because it is fragile. Welcome to C. Use a less fragile system where you can.
T Duncan Smith
2010-04-09 03:03:35
I remember some Motif (of all things) code awhile back where you would get a pointer in, and you would look at the first bytes after the pointer to determine what the type was, and then you deal with that type appropriately. What a mess.
WhirlWind
2010-04-09 03:05:25
I won't be doing this in practice. I was just curious of ways that this can be done. Also, A GNU C extension provides the typeof() operator which (I think) will be able to determine the type of what's dereferenced (i.e. typeof(*p)), but I haven't used it yet.
Yktula
2010-04-09 03:09:56
I'd guess typeof will tell you "void," since there's no way for the compiler to know at compile time.
WhirlWind
2010-04-09 03:12:56
there's no way typeof() can reliably infer the type of a void*. it might be able to do something, if that pointer points to an object that was allocated by the heap-allocator used by the standard memory allocation library used by the compiler; however, if that pointer points to an object that is allocated by a custom heap allocator (your own new operator) or was allocated by OS API (OLE SAFEARRAY) or by code in a different language (a VB5 COM component or POCO object exposed through managed C++), it's impossible to do anything.
Franci Penov
2010-04-09 03:27:50
@WhirlWind, 255 possible types sounds very limited though :P@Yktula, RTTI, or more precisely, the typeid operator, doesn't query the type_info hierarchy for void pointers because they have none. So it can't guess what type it points to.
jweyrich
2010-04-09 03:36:52
`typeof` only tells you the static/compile-time type. So if you have `void *p`, `typeof(*p)` -> `void`.
R Samuel Klatchko
2010-04-09 04:32:59
+3
A:
Short answer - you cannot.
In C there's no runtime time information unless you provide it, but look at the printf(3) family and see how easy it is to shoot yourself in the foot with mismatched format spec and actual argument type.
Type system is your friend. Use it.
Nikolai N Fetissov
2010-04-09 03:24:02
+2
A:
Sure you can, and it's easy too. It's C, do whatever you want, how you want it.
Make a type system. Put everything you pass into a structure, make the first byte or two a magic number to determine what the structure contains beyond the magic number.
Make some functions to create/get/set/destroy the "typed variables".
Make some other functions to add and register new types at runtime.
Create a few defines to make it easier to read and typecast the structs.
Before you know it you will have a nice proprietary type system you can use for your projects, and it will always do EXACTLY what you want and need because YOU made it.
You could go crazy and grow it into a full object oriented like system. Or save yourself the work, and use the work of all the other people who already went crazy - http://en.wikipedia.org/wiki/GObject
So, how does this work when the function you write is called from code you don't control?
WhirlWind
2010-04-09 03:53:20