I have always been curious about this - why do in C++ I have to cast return value from malloc
but not in C?
Here is the example in C++ that works:
int *int_ptr = (int *)malloc(sizeof(int*));
And here is the example in C++ that doesn't work (no cast):
int *int_ptr = malloc(sizeof(int*));
I heard that in C, in fact, casting an output from malloc()
is a mistake.
Can anyone comment on this topic?
Several points:
C allows void pointers to be implicitly converted to any other object pointer type. C++ does not.
Casting the result of
malloc()
in C will supress a useful diagnostic if you forget to include stdlib.h or otherwise don't have a declaration formalloc()
in scope. Remember that if C sees a function call without a prior declaration, it will assume that the function returnsint
. If you don't have a declaration formalloc()
and you leave off the cast, you'll get a diagnostic to the effect that you're trying to assign incompatible types (int to pointer). If you cast the result, you supress the diagnostic and will potentially have runtime issues, since it's not guaranteed that converting a pointer value to an int and back to a pointer again will give you a useful result.If you're writing C++, you should be using
new
anddelete
instead ofmalloc()
andfree()
. Yeah, yeah, yeah, I've heard all the reasons why people want their code to compile as both C and C++, but the benefits of using the right memory management tool for the language outweigh the cost of maintaining two versions IMO.Note: the
void *
type was added in the C89 standard; earlier versions of C hadmalloc()
returnchar *
, so in those versions the cast was required if you were assigning the result to a different pointer type. Almost everybody supports at least the C89 standard though, so the odds of you running into one of those older implementations is very, very low.That's because C++ is a strongly-typed language. In C++, implicit casts are only allowed if they are "widening", that is, if the new type can hold every value that the old type can hold. Casting from a smaller integer type to a larger integer type is allowed; casting from any pointer type to
void*
is allowed; casting from a subclass to its superclass is allowed. All other casts must be made explicitly, thereby telling the compiler "I know what I'm doing, this is not a mistake".malloc()
returns avoid*
, which could be anything, so the compiler cannot guarantee that your cast will succeed (or be meaningful). By using an explicit cast, you're telling the compiler that what you're doing is actually intentional.C, OTOH, does not have such rigid casting rules; you can happily cast between any two types, and you as the programmer are responsible for making sure no bad things happen as a consequence.
C supports implicit cast from
void*
to other pointer types. C++ disallows it.One reason that it's frowned upon in C to explicitly cast the return value of
malloc
is that if themalloc
signature is not included in the current compilation unit, the compiler will assume that the return type isint
and implicit conversion of it to the pointer type you're assigning to results in a compile-time warning you'd immediately resolve. With an explicit cast, if you make this mistake, no warning will be issued.