Casting void pointers
c, pointers, void-pointers
Solution
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`. In C++, the casting is needed (but there you should be using `new` instead of `malloc` most of the time).
Update
My comments below that try to explain why the cast is required were a bit unclear, I'll try to explain it better here. You might think that even when `malloc` returns `char *`, the cast is not needed because it is similar to:
int *a;
char *b = a;
But in this example a cast is also needed. The second line is a constraint violation for the simple assignment operator (C99 6.5.1.6.1). Both pointer operands need to be of compatible type. When you change this to:
int *a;
char *b = (char *) a;
the constraint violation disappears (both operands now have type `char *`) and the result is well-defined (for converting to a char pointer). In the 'reverse situation':
char *c;
int *d = (int *) c;
the same argument hold for the cast, but when `int *` has stricter alignment requirements than `char *`, the result is implementation defined.
Conclusion: In the pre-ANSI days the type cast was necessary because `malloc` returned `char *` and not casting results is a constraint violation for the '=' operator.
Problem
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?