I learned this today at my work place. And I read this, this and this before posting my question.
Here's what my senior co-worker told me:
You cannot assign void* to UINT or unsigned int. It won’t work for 64 bit.
But why? Is it because void* and unsigned int carry different sizes on different architectures (as mentioned in other questions), or something else?
You're essentially correct: It is not guaranteed that an unsigned int has the same machine word length as a void*, so you can't cast between them without losing information. Here is an excellent FAQ answer about it.
The main thing to keep in mind is that void* is an arbitrary data pointer, not a truly arbitrary pointer. In fact, there is no such thing as a truly generic pointer: certain machines may have different address spaces for programs and data, for example, so the sizes of pointers to each might differ. See this SO answer for more info.
Yes, that is the case.
Your implementation may provide the optional type uintptr_t, however, which is defined as follows:
The following type designates an unsigned integer type with the property that any valid pointer to void can be converted to this type, then converted back to pointer to void, and the result will compare equal to the original pointer:
uintptr_t
The signed counterpart intptr_t may also be available. These types are available in the <cstdint> header.
By choosing to use these types, you are acknowledging that your code will only compile with the subset of implementations that provide this types on your target machines.
Size is obviously a show-stopper, if void* can't physically fit in an unisigned int the game is over. But even if sizeof(void*) == sizeof(unsigned int) you have a type compatibility problem: one holds a data pointer, the other data. You'd have to reinterpret_cast<>() the one to the other and all bets are off as to how well this would work.
Depends on the target for your application. You tagged VC++ and mention type UINT - thus it seems that you're building for Windows. In 32-bit Windows the pointer size is 32 bit, while in 64-bit Windows it's 64 bit. However, size of type UINT is defined similarly to 32 bit for both Windows flavors. You can use __uint64 or UINT64 MS-specific type instead of UINT to ensure it's big enough for your pointer. You can also use INT_PTR/UINT_PTR types which are specifically designed to match the size of the pointer (thus making it transparent for 32/64-bit flavors).
See http://msdn.microsoft.com/en-us/library/s3f49ktz.aspx for reference on various data types.
Of course, all of these will make your program not natively portable to other architecture/OSes.
