The cast to int*
masks the fact that without the proper #include
the return type of malloc
is assumed to be int
. IA-64 happens to have sizeof(int) < sizeof(int*)
which makes this problem obvious.
(Note also that because of the undefined behaviour it could still fail even on a platform where sizeof(int)==sizeof(int*)
holds true, for example if the calling convention used different registers for returning pointers than integers)
The comp.lang.c FAQ has an entry discussing why casting the return from malloc
is never needed and potentially bad.
Most likely because you're not including the header file for malloc
and, while the compiler would normally warn you of this, the fact that you're explicitly casting the return value means you're telling it you know what you're doing.
That means the compiler expects an int
to be returned from malloc
which it then casts to a pointer. If they're different sizes, that's going to cause you grief.
This is why you never cast the malloc
return in C. The void*
that it returns will be implicitly converted to a pointer of the correct type (unless you haven't included the header in which case it probably would have warned you of the potentially unsafe int-to-pointer conversion).
This is why you never compile without warnings about missing prototypes.
This is why you never cast the malloc return in C.
The cast is needed for C++ compatibility. There is little reason (read: no reason here) to omit it.
C++ compatibility is not always needed, and in a few cases not possible at all, but in most cases it is very easily achieved.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With