void-pointers

I just saw a picture today and think I'd appreciate explanations. So here is the picture: I found this confusing and wondered if such codes are ever practical. I googled the picture and found another picture in this reddit entry, and here is that picture: So this "reading spirally" is something valid? Is this how C compilers parse? It'd be great if there are simpler explanations for this weird code. Apart from all, can these kind of codes be useful? If so, where and when? There is a question about "spiral rule", but I'm not just asking about how it's applied or how expressions are read with

In Visual Studio C++ version 9 (and probably other versions too), the following code: int a = sizeof(void); void const *b = static_cast<void const *>("hello world"); b += 6; Generates these errors : error C2070: 'void': illegal sizeof operand error C2036: 'const void *' : unknown size This code works under GCC, which treats sizeof(void) as 1 . Is there some way around this limitation, as casting explicitly to char * for purposes of pointer arithmetic adds to the confusion ( void * is well recognised and used as a typeless pointer to raw memory). Update0 Please note, I'm well aware of the

My program needs to make use of void* in order to transport data or objects in dynamic invocation situation, so that it can reference data of arbitrary types, even primitive types. However, I recently discovered that the process of down-casting these void* in case of classes with multiple base classes fails and even crashes my program after invoking methods on these down casted pointers even if the memory addresses seem to be correct. The crash happens during access to "vtable". So I have created a small test case, environment is gcc 4.2 on Mac OS X: class Shape { public: virtual int w() = 0;

I've seen a lot of the following in older C code: type_t *x = (type_t *) malloc(...); What's the point of casting the pointer returned from malloc() since it's void * ? Is it because older C compilers didn't support void pointers and malloc() used to return char * instead? 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 a missing prototype of malloc .

While working with Threads in C, I'm facing the warning "warning: cast to pointer from integer of different size" The code is as follows #include<stdio.h> #include<sys/types.h> #include<stdlib.h> #include<pthread.h> void *print(void *id) { int a=10; printf("My thread id is %ld\n",pthread_self()); printf("Thread %d is executing\n",id); return (void *) 42; } int main() { pthread_t th[5]; int t; int i; int status; void *ret; for(i=0;i<5;i++) { status=pthread_create(&th[i],NULL,print,(void *)i); //Getting warning at this line if(status) { printf("Error creating threads\n"); exit(0); } pthread_join

According to this , void* has no RTTI information, therefore casting from void* is not legal and it make sense. If I remember correctly, dynamic_cast from void* was working on gcc. Can you please clarify the issue. vitaut 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 } In 5.2.7 - Dynamic cast [expr.dynamic.cast] it says that for dynamic_cast<T>(v) : If T is a