Array and Pointer Basics

A pointer is useful only if you can move in two directions: from an object to its address, and from a pointer back to the object it points to. This article is about those two moves. Each one is a prefix unary operator, meaning it sits directly in front of the single operand it acts on. The ampersand goes from an object to its address. The asterisk goes from a pointer to the object it points to.

The result of the ampersand is an address, not the element's value. The address-of operator answers the question 'where is this object?' It does not answer 'what is stored in this object?' Keeping those two questions apart is the main skill this article builds.

In the source's example, applying the ampersand to v[3] yields the address of the fourth element of v. A pointer declaration such as the one below is read as 'p is initialized to the address of v[3]'. The declaration gives p a target. It does not copy the element anywhere.

Now follow the operations one at a time. Start with the declaration that stores the address of v[3] in p. Then apply the prefix asterisk to p and watch what object each step refers to. The diagram below shows the path. The pointer p reaches the fourth element, and the value read through p is what gets copied into x.

Dereferencing is the step that moves from the pointer back to the value it leads to. In the source's initialization, a variable x is set from the object p points to. The source phrases it this way: the object that p points to is written as the prefix asterisk applied to p.

Both operators are prefix unary operators, and they point in opposite directions. The same written form can therefore mean very different things depending on what follows it. A useful check for any expression is to ask what kind of thing the operator acts on. An object goes into the ampersand and an address comes out. A pointer goes into the asterisk and an object comes out. If you apply an operator to the wrong kind of operand, the expression no longer means what you intended.

Reading *&v[3] from the inside out: the ampersand acts on v[3] and produces its address. The asterisk then acts on that address and gives back the object at that address, which is v[3]. The two operations undo each other, so the whole expression refers to v[3]. The inner operator applies first, which is why evaluating the expression from left to right on the page can mislead you.

The source introduces these operations with a practical goal: copying ten elements from one array to another. Once a pointer can reach an element and that element's contents can be read through the pointer, the program can work on array elements through pointers instead of naming each element directly. The example below is an illustration of that idea and is not taken from the source.