Is it a good idea to use intptr_t as a general-purpose storage (to hold pointers and integer values) instead of void*? No. intptr_t is not guaranteed to exist. First, as you note, it was introduced in C99. Second, implementations are not required to have an integer type big enough to hold converted pointer values without … Read more
You just need to dynamically allocate it (because it probably needs to outlive the scope you’re using it in), then cast it back and forth: // Cast a dynamically allocated string to ‘void*’. void *vp = static_cast<void*>(new std::string(“it’s easy to break stuff like this!”)); // Then, in the function that’s using the UserEvent: // Cast … Read more
TL/DR: the book is wrong. What am I missing? Nothing, as far as I can see. Even the erratum version presented in comments … A pointer to void will never be equal to another pointer to void. … simply is not supported by the C language specification. To the extent that the author is relying … Read more
A quick hacky fix might just to cast to long instead of int. On a lot of systems, sizeof(long) == sizeof(void *). A better idea might be to use intptr_t. int threadnumber = (intptr_t) param; and pthread_create(&(tid[i]), &attr, runner, (void *)(intptr_t)i);
Only data pointers. void * can hold any data pointer, but not function pointers. Here is a C FAQ. void *’s are only guaranteed to hold object (i.e. data) pointers; it is not portable to convert a function pointer to type void *. (On some machines, function addresses can be very large, bigger than any … Read more
For types for which such cast is permitted (e.g. if T1 is a POD-type and T2 is unsigned char), the approach with static_cast is well-defined by the Standard. On the other hand, reinterpret_cast is entirely implementation-defined – the only guarantee that you get for it is that you can cast a pointer type to any … Read more
Is there any way to disable implicit conversion to void* for pointers to a certain class? No, you can’t prevent the implicit conversion, but you could wrap the API function(s) in proxy functions that checks types at compile time and approve/disapprove them there. Example: #include <iostream> #include <string> #include <type_traits> void api(void* p) { // … Read more
The two concepts are orthogonal: A void pointer, (void *) is a raw pointer to some memory location. A null pointer is a special pointer that doesn’t point to anything, by definition. It can be a pointer to any type, void or otherwise. A void pointer can be null or not: void *void_ptr1 = nullptr; … Read more
dynamic_cast works only on polymorphic types, i.e. classes containing virtual functions. In gcc you can dynamic_cast to void* but not from: struct S { virtual ~S() {} }; int main() { S* p = new S(); void* v = dynamic_cast<void*>(p); S* p1 = dynamic_cast<S*>(v); // gives an error }
If you did have a reference to void, what would you do with it? It wouldn’t be a number, or a character, or a pointer, or anything like that. Your hypothetical generic function couldn’t perform any operation on it, except taking its address (and not its size). “void” has two uses: to disclaim any knowledge … Read more