Why does C++ require a cast for malloc() but C doesn't?

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 for malloc() in scope. Remember that if C sees a function call without a prior declaration, it will assume that the function returns int. If you don't have a declaration for malloc() 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 and delete instead of malloc() and free(). 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 had malloc() return char *, 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 a void*, 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 the malloc signature is not included in the current compilation unit, the compiler will assume that the return type is int 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.