Programming Forums - relation between array and pointer

A third, and longer, explanation follows.

The difference between pointers and arrays comes down to how they are declared, and the things in common are related to how they are subsequently used.

A pointer is a variable which holds the address of something. In the basic form, it is declared using syntax like this;

SomeType *pointer;

which gives a pointer.

An array is a set of elements which are located adjacent to (i.e. beside) each other in memory, and each element is identified by an index. For example;

SomeType array[5];

declares an array of 5 elements. The individual elements are array[index] where index is an integer between 0 and 4 inclusive.

So, when they are declared, there is no relationship between an array and a pointer.

After they are declared, the language allows them to be used interchangeably in some ways. The most obvious one is that the name of an array is (as far as the compiler, and therefore the program being compiled, is concerned) treated like it is a pointer to that array's first element.

Because of this, a pointer can be made to point at an array (or that array's first element). For example;

pointer = array; // same as pointer = &array[0];

This is achieved by what is called an "implicit conversion". The name of the array is implicitly converted into a pointer (i.e. the compiler does that for you behind the scenes).

The reverse, however, is untrue .... so we can't do this;

array = pointer; // invalid operation

because a pointer cannot be quietly converted into an array.

Things get even more entertaining when we attempt to dereference a pointer (i.e. access the thing it points at) or to access an element of an array. If we assume the value of pointer is the address of a valid SomeType, that SomeType can be accessed by dereferencing the pointer. If the assignment "pointer = array" was done above, then

*pointer = SomeValue;

will set array[0] to be SomeValue. In other words, this would have the same result as;

array[0] = SomeValue;

From this, we might assume that dereferencing a pointer and accessing a value by index do the same thing. And, in C and C++, that is exactly true. So the third way of doing this is;

pointer[0] = SomeValue;

And since we play with a pointer like it is an array, we might take a guess and say that we could do the same thing by dereferencing array using the * notation. And, in fact, C/C++ allow us to do this as well, so we have a fourth way to assign array[0] to be SomeValue;

*array = SomeValue;

Keep in mind that this is only hunky dory if "pointer" contains the address of array[0]. And we can go further, and use pointer notation to access elements of array, or use array notation to find a variable that is offset from array[0]. For example, all of the following lines set array[3] to be SomeOtherValue;

    array[3] = SomeOtherValue;

    pointer[3] = SomeOtherValue;

    *(pointer + 3) = SomeOtherValue;

    *(array + 3) = SomeOtherValue;

The brackets in the last two lines are necessary because of the precedence of operators in the language: "*pointer + 3" has the same result as "pointer[0] + 3", whereas "*(pointer + 3)" yields the same result as "pointer[3]".

From the above, one might think that a pointer is an array and an array is a pointer. That is wrong. An array as a number of elements. A pointer only contains an address, so the assignment;

pointer = array;

does not make pointer become an array. pointer does NOT have any information about the size of array --- because it only contains the address of the first element of our array. This becomes noticeable when we have a function that accepts a pointer as an argument. For example;

void f(SomeType *x)

{

     x[3] = SomeValue;   // ASSUME x is the address of the first element of an array

                                 //  and ASSUME that array has 4 or more elements

}



int main()

{

     SomeType *pointer;

     SomeType array[5];

     SomeType aValue;



     f(array);     // OK.  The assumptions made by f() are valid

     f(pointer);  //  Undefined behaviour.  pointer is not initialised to point at anything



     pointer = array;



     f(pointer);   // OK.  The assumptions made by f() are valid

     

     pointer = &aValue;



     f(pointer);    // Undefined behaviour.  pointer contains a valid address

                      //  but that address is not the first element of an array

                      //  of 4 or more elements.

}

This little example illustrates the difference between pointers and arrays. f() ASSUMES that the pointer it receives is the pointer to the first element of an array with 4 or more elements. As long as main() honours that assumption, all works fine. But in cases where main() fails to honour that assumption, the result is what the C and C++ standards call "undefined behaviour" --- anything is allowed to happen (a common symptom is a crash, but whether the program crashes or not, it is still invalid behaviour).

The thing to realise is that, in this example, f() receives a pointer and has no means of detecting if that pointer is really an array or not. So there is no means of determining if an array is passed or not. A consequence of this is that f(), because it can't even determine IF it's argument is an array, it certainly can't extract the size of that array (if any).