# Is an array name a pointer?

An array is an array and a pointer is a pointer, but in most cases array names are converted to pointers. A term often used is that they decay to pointers.

Here is an array:

``````int a;
``````

`a` contains space for seven integers, and you can put a value in one of them with an assignment, like this:

``````a = 9;
``````

Here is a pointer:

``````int *p;
``````

`p` doesn’t contain any spaces for integers, but it can point to a space for an integer. We can, for example, set it to point to one of the places in the array `a`, such as the first one:

``````p = &a;
``````

What can be confusing is that you can also write this:

``````p = a;
``````

This does not copy the contents of the array `a` into the pointer `p` (whatever that would mean). Instead, the array name `a` is converted to a pointer to its first element. So that assignment does the same as the previous one.

Now you can use `p` in a similar way to an array:

``````p = 17;
``````

The reason that this works is that the array dereferencing operator in C, `[ ]`, is defined in terms of pointers. `x[y]` means: start with the pointer `x`, step `y` elements forward after what the pointer points to, and then take whatever is there. Using pointer arithmetic syntax, `x[y]` can also be written as `*(x+y)`.

For this to work with a normal array, such as our `a`, the name `a` in `a` must first be converted to a pointer (to the first element in `a`). Then we step 3 elements forward, and take whatever is there. In other words: take the element at position 3 in the array. (Which is the fourth element in the array, since the first one is numbered 0.)

So, in summary, array names in a C program are (in most cases) converted to pointers. One exception is when we use the `sizeof` operator on an array. If `a` was converted to a pointer in this context, `sizeof a` would give the size of a pointer and not of the actual array, which would be rather useless, so in that case `a` means the array itself.