On many systems a double is 8 bytes wide and a pointer is 4 bytes wide. The former, therefore, would not fit into the latter. You would appear to be abusing void*. Your solution is going to involve allocating storage space at least as big as the largest type you need to store in some … Read more
Your own explanation is the right one. Pre-ANSI C (‘K&R’ C) did not have a void * type with implicit conversion. char * doubled as a pseudo void * type, but you needed the explicit conversion of a type cast. In modern C the casting is frowned upon because it can suppress compiler warnings for … Read more
Maybe. Until C++11, they couldn’t; but C++11 adds: Converting a function pointer to an object pointer type or vice versa is conditionally-supported. The meaning of such a conversion is implementation-defined, except that if an implementation supports conversions in both directions, converting a prvalue of one type to the other type and back, possibly with different … Read more
This is a fine way to pass integers to new pthreads, if that is what you need. You just need to suppress the warning, and this will do it: #include <stdint.h> void *threadfunc(void *param) { int id = (intptr_t) param; … } int i, r; r = pthread_create(&thread, NULL, threadfunc, (void *) (intptr_t) i); Discussion … Read more
Incrementing a pointer is technically supposed to increment it by whatever size of thing that its pointing at. Void points at nothing, so the size is unknown. Its a nicety for some compilers to let you increment void pointers. Casting is annoying, because you have to either cast it to another pointer, and then back, … Read more
There is a rule called the “Clockwise/Spiral Rule” to help find the meaning of a complex declaration. From c-faq: There are three simple steps to follow: Starting with the unknown element, move in a spiral/clockwise direction; when ecountering the following elements replace them with the corresponding english statements: [X] or [] => Array X size … Read more
It defines a pointer-to-function type. The functions return void, and the argument list is unspecified because the question is (currently, but possibly erroneously) tagged C; if it were tagged C++, then the function would take no arguments at all. To make it a function that takes no arguments (in C), you’d use: typedef void (*MCB)(void); … Read more
A void* does not mean anything. It is a pointer, but the type that it points to is not known. It’s not that it can return “anything”. A function that returns a void* generally is doing one of the following: It is dealing in unformatted memory. This is what operator new and malloc return: a … 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 }
Yes, it is the signature of a nameless function pointer that takes and returns void *. If it had a name (as in a variable) it would be: void *(*myFuncName)(void*)