Many of the integral types have shorter names, because the keyword int can be omitted after short or long.  (In C89, you can omit it in even more cases, but C99 has pretty much eliminated ‘implicit int’.)  The type char (sometimes called ‘plain char’) has exactly the same characteristics -- minimum and maximum values, and sizeof -- as either signed char or unsigned char, at the implemention's discretion.  Often int is ‘similarly similar’, as it were, to either short or long.  Nonetheless, all of these types are considered distinct, and it is an error to mix them (as with pointers, below) even when the characteristics match.  (This is one reason C can be considered ‘strongly typed’.)

As a special case, C has enumerated types, which are ‘compatible with’ some integral type, but are nonetheless distinct types.  As another special case, C offers the void type, which is just an incomplete type that can never be completed.  There are no actual values of type void, which is something of a self-contradiction.  (Think of it as the empty set of values.  Since all null sets are identical, it really does not matter what value it has, or does not have.)

These basic types are used to build the derived types.  The derived types can sometimes also refer to the incomplete and function types.  The derived types are:

• Structures and unions.  These are simply collections of objects.  C99 adds a special feature wherein the last member of a structure can be an array whose size is omitted (an incomplete type); otherwise these all have to be complete types.  Unions are just a special case of structures, wherein the various members overlap, so that you can only use one of them at a time.
• Functions.  These are reasonably conventional -- a function has some fixed set of parameters of fixed types, and a return type.  For instance, the remove() function in <stdio.h> takes, as its parameter, a file name, and returns a value of type int indicating success or failure.  Thus remove() can be said to be a ‘function returning int’, or, in more detail, a ‘function (of one argument of type const char *) returning int.  (The const here is a ‘type qualifier’.)
• Arrays: an array has a size and an element type.  The size is sometimes optional, but the element type is always required.  The element type must be an object type -- function and incomplete types are not legal here.  If the size is a known constant N and the element type is T, the array can be said to be an ‘array N of T’.  If N is not known or is omitted, the array can simply be called an ‘array of T’.   (In this case the array itself is an incomplete type.)  C99 adds a new wrinkle: array sizes no longer need to be constant.
• Pointers: pointers always point to some particular type, called the reference type.  Unusually, the reference type here can be any object, function, or incomplete type.  The reference type has to be fixed in advance, though, and -- with a few exceptions to be addressed later -- when the reference type is ‘pointer to T’, this pointer can only point to things of type T.  For instance, a pointer of type ‘pointer to int’ can only point to ints; attempting to make one point to a double is not a good idea.

Values

In a departure from most other similar languages (even including C++), character constants like 'a' have type int.

The set of operations allowed on any value, and the meaning of those operations, are determined entirely by the type of that value.  (This is the other main requirement to call C a strongly typed language.)  For instance, the precise action of the right-shift operation >> may change depending on whether the value being shifted is signed or unsigned.  This is why it is crucial to keep track of the type of each value. If you do not know the type as well as the value, you cannot predict the outcome of the operation.

For this reason, when analyzing any particular expression in C, you should write down both the type and the value of each sub-expression.  I like to write them in pairs, enclosed in angle brackets:

42 is an <int, 42>
3.14159F is a <float, 3.14159>

Conversions

Many of C's conversions will happen automatically.  That is, given something like:

int i = 3;
double d = 3.14159;

char c = 'A';

A cast is a syntactic construct that forces a conversion.  The syntax is a type-name enclosed in parentheses, and the result of a cast is a new value with a new type.  The new type is just the type-name inside the parentheses, and usually, the new value is just the value that would result from an automatic conversion.  That is:

(double)i

This leads to a general rule: Be suspicious of any cast, especially pointer casts.  Unfortunately, some C compilers are unnecessarily picky about converting from, e.g., int to short, producing warnings if the programmer does not shut them up with a cast.  Equally unfortunately, many C programs contain questionable -- or outright wrong -- pointer conversions, and many C programmers have learned to disable warnings about them by sprinkling casts in liberally.  After all, one typical diagnostic is ‘warning: integer to pointer conversion without a cast’, practically begging the programmer to insert a cast blindly, rather than figuring out why the compiler thinks one of the values involved is an integer.

The  void *  weirdness

What makes this particularly weird is that void ** cannot point to just any pointer.  The special type void * works as a generic pointer, converting freely to or from any other pointer type, but it is a unique type -- an ‘anyptr’, as it were -- in and of itself.  The type void ** can only point to these special pointers.  Even though void * can point to any other type (including another void *), void ** can only point to void *.