Why is pointing one position beyond a valid object acceptable for pointers?

Question

In the textbook "Modern C" by Jens Gustedt, I read for pointers that "A pointer must point to a valid object or one position beyond a valid object or be null.". Why is pointing to one position beyond a valid object acceptable? E.g.:

int array[5] = {0};
int* p = array;
p = array + 5 // points to a valid location
p = array + 6 // points to an invalid location

Answer 1

Supporting “one beyond the last” makes working with arrays simpler. For example, if a function is called with a pointer Start to some element, it might want to prepare an end pointer End and use a loop such as:

for (ElementType *p = Start; p < End; ++p)

To do this, End must be a valid pointer.

We might consider instead setting End to be the last element to be processed, rather than one beyond it, and using:

for (ElementType *p = Start; p <= End; ++p)

However, note that, after the final element is processed, p will be incremented to beyond End. Then, in order for p <= End to be a valid expression, p must be a valid pointer. So, we need to be able to do address arithmetic up to one beyond the last element of an array.

Answer 2

Your code comments express a probable misunderstanding. With ...

int array[5] = {0};
int* p = array;
p = array + 5 // points to a valid location

... p does not point to a valid location. It is allowed and well defined to evaluate array + 5, and that produces a value that p can store, but undefined behavior results from any attempt to dereference that pointer value.

Such a value for p is sometimes useful as an exclusive upper bound on the addresses of elements of array, or for indexing array backwards (with strictly negative indexes), but you may not attempt to access a value through that value itself.

In contrast, in this case ...

p = array + 6 // points to an invalid location

... p does not point to anything, at least inasmuch as can be determined by analysis of the code. Attempting to evaluate the expression array + 6 produces undefined behavior, and in particular, the result is not well defined.