Should I explicitly cast malloc()'s return value?

I wanted to ask about the following case:

char *temp;
temp = malloc(10);

Since the return type of malloc is void*, will the pointer returned by the malloc be implicitly cast to char* type before being assigned to temp? What does the standard say in this regard?

If our pointer variable is some struct type for example:

struct node *temp;
temp = (struct node *)malloc(sizeof(struct node));

If we allocate memory to temp without casting it to struct node* type, will it be implicitly cast to struct node* type or is it necessary to explicitly cast it to struct node* type?

If you like the "don't repeat yourself" mindset, it should be appealing that you don't need to repeat the type name from the declaration of the variable, in the malloc() call. Because, as folks have pointed out, you don't: pointers convert to and from void * without loss, with the exception of function pointers.

Also, on that note, you don't need to repeat yourself with the use of sizeof either. Your second example, when allocating a structure, can be written like this:

struct node *temp;
temp = malloc(sizeof *temp);

Which in my not so humble opinion is the best way.

Avoiding repeating yourself cuts down on the number of things you write, which in turn cuts down on the risk that any of those things are wrong.

Note the asterisk in the sizeof argument, this means "the size of the object pointed to by this pointer", which is of course the same as "the size of the type struct node" but without repeating the type name. This is because sizeof computes (at compile-time!) the size of the expression that is its argument. For this case. Just like sizeof 3 computes the size of an expression of type int, sizeof *temp computes the size of an instance of struct node.

Sure, you do repeat something, i.e. the variable name itself, but that is often a simpler expression and easier to get right, and also can be easier for the compiler to spot an error in.

A void pointer in C can be assigned to any pointer without an explicit cast.

C implicitly casts from and to void*, so the cast will be done automatically. In C++ only conversion to void* would be done implicitly, for the other direction an explicit cast is required.

In C++ you must explicitly cast, but this is really just the language telling you off for doing it.
In c there isn't really any need to cast, memory is just memory - I will have to do a search to see if the latest C standard requires it.