Is Typecast from malloc recommended?

It is really not recommended to perform typecast, at least in C. The malloc return is in its essence a pointer to void (void*), being then implicitly converted to another pointer type.

As complications, I say from experience, the use of typecasts in C can mask problems that the compiler could ideally identify.

More information, in C-FAQ http://c-faq.com/malloc/cast.html

It is not recommended to cast to the result of malloc() for the compiler to indicate the error of missing #include <stdlib.h>.

Since the compiler has no information about the result type of malloc() it assumes that this function returns a value of type int. After

v = (int *) malloc(sizeof(int));

The explicit conversion converts this int (at this point you have already invoked UB, since you are treating the returned value as if it were a different type than it actually is) into a int *. Note that this conversion is not valid, but as it was an explicit request from the programmer the compiler does not complain. Finally the new (invalid) value of type int * is assigned to variable.

Without explicit conversion, the compiler would complain about the automatic conversion between int (the type of value it assumes the function malloc() returns) and int * - - - which would lead the (experienced) programmer to add the correct header.

More notes

Sem #include <stdlib.h>

    int *v, *x, *z;
    v = (int *)malloc(sizeof (int)); /* 1a */
    z = (int)malloc(sizeof (int));   /* 2a */
    x = malloc(sizeof (int));        /* 3a */

With #include <stdlib.h>

#include <stdlib.h>
/* ... */
    int *v, *x, *z;
    v = (int *)malloc(sizeof (int)); /* 1b */
    z = (int)malloc(sizeof (int));   /* 2b */
    x = malloc(sizeof (int));        /* 3b */

1A {error

The malloc() returns a value of type int * which is assumed to be int due to the absence of the correct prototype. In addition, the explicit conversion of this int to int * is invalid, but since it was an explicit request from the programmer, the compiler does not complain.

1B Red redundancy

Since malloc() returns a value of Type void *, this value would be automatically converted to int * during assignment to v (pointers to void are compatible with pointers to any type). Redundancy is not a mistake, but it is unnecessary. nobody writes return ((((42)))); /* parenteses redundantes */

2A Erro error and redundancy

In the first case we have a value of type void* returned by the malloc() interpreted as int because of the absence of the correct header. After that we have the redundancy of asking the conversion of int into int. The following is the assignment of a type value int the variable of type int * is wrong, but the compiler has to complain. Note that in this case the error has nothing to do with the use of malloc() or the conversion of the result. Assigning a int to a int * is wrong.

2B {error

As in 2a, the error does not have to do with the use of malloc() or the conversion of the returned value.

3A {error that the compiler complains about and easily fixes itself

When the compiler complaint of assigning a value of type int to a variable of type int * (the gcc has an misleading text for this spicific error), the programmer notices that he missed the inclusion of the header <stdlib.h>.

3B OK OK

Correct way to use malloc().

Plus a tip (to avoid future problems if the variable type changes, for example, from int capacidade to double capacidade)

    int *capacidade;
    /* ... */
    capacidade = malloc(200 * sizeof (int));
    /* ... */
    free(capacidade);

At some point someone remembers that it will be it is necessary to have, for example, 3.14159 capacity and it is decided to change the type to double. In these conditions it will be necessary to change the code in 2 places: in the definition and in the allocation.
Using the object itself in the allocation, only changes in the definition

    double *capacidade;
    /* ... */
    capacidade = malloc(200 * sizeof *capacidade); // usa o tipo do objecto
    /* ... */
    free(capacidade);