"If the return of malloc is cast then the error which would be flagged is hidden, resulting in a difficult to find bug"
the above stmt is mentioned in the reference
<html>http://faq.cprogramming.com/cgi-bin/smartfaq.cgi?id=1043284351&answer=1047673478</html>
Kindly explain me this with an example
I think you should just understand this conceptually (i.e., in the absence of a prototype, a function is assumed to have a return type of int), since this is a kind of bug that may be inconsistently demonstrated.
Look up a C++ Reference and learn How To Ask Questions The Smart WayOriginally Posted by Bjarne Stroustrup (2000-10-14)
Where I've seen this is when I forget to include <stdlib.h>, and cast the return from malloc (doesn't matter what the data type is, apparently). Which backs up Laserlights assertion, btw.
Normally, if I try to use malloc w/o including stdlib.h, I'd get an error from the compiler. With the cast there, I get no error, at all. The program just fails on malloc, or crashes if I haven't included any check on the return from malloc().
Any program you're serious about, always check your return from the function call.
The way I read it is the using the cast without including the proper header will result in a link error or warning. Note: An compiler warning might/should happen also; but might not be very informative.
But, not using the cast will result in a compiler warning/error if the header is not included.
Because a compiler waring/error is preferred by most programmers over an Linker warning/error the recommended choice is not to use the cast.
Tim S.
Last edited by stahta01; 08-03-2010 at 05:02 PM. Reason: Added Note
It's a minor point that has to do with how compiling/linking works.
If you are just starting out, I wouldn't worry about it for now. It's not that important.
If you are still interested, what happens is, in C, if you use a function without first declaring it, it's assumed to return int. And this code will fail to compile
Because an int cannot be implicitly casted to a pointer.Code:SomeType *ptr = malloc(...);
Adding a cast
allows the code to compile, because you explicitly casting the "int" to a pointer, and it will fail at link time instead, because although malloc is implicitly declared, it is not defined.Code:SomeType *ptr = (SomeType *) malloc(...);
Actually, it would link just fine because malloc() is part of the standard library. That's even worse, because now you have a silently wrong program and no way of knowing it.
Some modern compilers will warn if a well-known function hasn't been prototyped.
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
Ah I see. I thought malloc is defined inline by stdlib.h.
That is very bad then, if sizeof(int) != sizeof(void *).
Ohoho. If you think an int cannot be implicitly converted to a pointer then you don't much about C. People here do it all the time.
Usually we get a warning about an integer being converted to a pointer (!).
Even worse.
Anyway yeah, bad.
