1) Know the amount of memory it takes at compile/link time.
2) If it is an automatic variable, it is allocated and deallocated
   automatically.
3) You can take the sizeof an array
4) You cannot change the addres of an array (this can be a plus)

Also, a pointer is not identical to an array. An array name degrades to a
pointer to the first element but a pointer to that same element actually
exists elsewhere. E.g.

int arr[10] = { 101 };
int *pArr = arr;

Say arr allocated at address 0xBEEF_C0DE
Say pArr lives at address 0xDEAD_C0DE, pArr will contain the value
0xBEEF_C0DE, which when dereferenced will point to the value 101.

Interesting. When I began using C, I used arrays almost exclusively - and avoided
malloc() as much as possible; then gradually shifted to using pointers /almost/
exclusively (except for declarations and definitions) and used malloc() much more.

As a result of working with "always on" systems with a limited number of fixed-sized
object types (but large numbers of each), I've been experimenting with maintaining a
recycling list for each size object. When I need a new instance of one of the
objects, I first check to see if there an unused one on the appropriate recycling
list; and malloc() only if the list is empty. Then, instead of free()ing objects when
no longer needed, I put 'em on the appropriate queue for re-use later. This is all
fairly straight foreward; but becomes more interesting when deciding how to deal with
the situation when malloc() no longer has memory available to allocate. In the most
interesting of these systems to date, a malloc() failure triggers configuration of
another machine on the network to perform the same function and transfer of half of
the data to the new machine - which, of course, makes more entries in the recycling
list on the original machine and allows a retry of the original request for an empty
object to succeed.

Array:

[0][1][2][3]

Pointer:

[p]->[0][1][2][3]

As others have pointed out, you don't want to use pointers for everything.

char *p;
p = "programming is fun";

is perfectly legitimate because the string constant "programming is fun" is
stored in some memory location to begin with, and setting the pointer to
point to that location will therefore work fine.

 char **month; /*pointer to pointer to char*/
 month = malloc(52); /*gives me 13 pointers, indexes 0-12*/
 month[1] = "January";
 month[2] = "February";
 month[3] = "March";
 month[4] = "April";
...etc...

I agree that a char month[13][10] is easier though, because when you can
initialize all the elements together using braces {} and hence not requiring
12 lines.

i.e. char month[13][10] = {"","January","February","March",...etc...};

But the pointer method has the advantage that later, if you want to change
all the month names to Spanish, you can directly assign without using strcpy
or anything. i.e. month[1] = "Enero"; etc.

On a semi-related note, that brings me to a question, if anyone knows the
answer feel free to chime in... If I allocate, say, 8 bytes of memory, for
example:

char *p;
p = malloc(8);

How can I define multiple dimensions for it, so I can use the memory as
p[2][4] or something instead of just p[8]? thanks

You can of course assign a value to a pointer, by pointing it to some
allocated memory.

char * month[12] = { "January", "February", "March", /* ... */ };