[sdeming]

The quick and dirty... Void tells the compiler that it shouldn't make any assumptions. There is a real long explination of it's purpose in the ANSI document, but it's hard to follow, so bare with me while I try and put it into realistic terms by use of example:

int intFun() { return 4; }

The compiler knows that this function returns an int, most likely 32 bits of data. This can be turned into the following assembly:

intFun:
mov eax, 0x00000004
push eax
ret

Now with void:

void voidFun() { // blah }

Evaluates to:

voidFun:
nop
ret

Now void pointers are another story altogether, and this is where compiler writers have to be careful, at least with ANSI C. C++ is another story and void *'s really aren't even useful any longer. So, let's see this in C:

char *cp;
int *ip;
void *vp;
int ival;

ival = 4;
ip = &ival;
cp = ip; /* this should be a compiler error, but is generally just a warning. */
cp = (char*)ip; /* okay, but bad style.  No warning, the compiler presumes that since you casted it you know what you're doing. */
vp = ip; /* perfectly okay. */
vp = cp; /* perfectly okay. */
cp = vp; /* also okay. */
ip = vp; /* again, okay. */

So basically, the compiler is instructed to morph void pointers to whatever they are representing. In almost every case the void pointers, char pointers, and int pointers are exactly the same size (based on the architecture, 32 bits for Intel and generally 64 bit for modern Sparc). The authors of the standard however did take into consideration that some older platforms (I think VMS??) did not operate in the same way and actually had pointers of different size. The compiler HAD to be aware of this and HAD to function with it.

All that said, compiler writers have generally disregarded these rules.

In C++ you have meta programming so void* is worthless. Templates make life grand!