Understanding Pointers and Arrays

A common task is counting how many times a particular character x appears in a sequence of characters. The usual approach uses an index: you step a number from the first position to the last and look up each character. There is another approach that needs no index at all. A pointer that points to the first element of an array can be moved forward, one element at a time, and reading the value it points to gives the character at that position. This article studies a short function, called count_x in the source, that counts occurrences of x this way.

The function is short enough to read in one pass, but its loop is exactly where many learners go wrong. As you work through the article, keep a guess in mind about what the loop is doing, and check that guess against the trace at each stage.

An array stores its elements one after another, so the elements sit side by side in memory. A zero-terminated array of char is an array whose last meaningful value is followed by a zero value. That zero marks the end of the array. The character written as '\0' is the zero value that serves as the terminator, so reading characters from the start, you know the sequence is finished when you reach it.

In this layout the characters b, a, n, a, n, a occupy the first six positions and the zero terminator occupies the seventh. The terminator is part of the array's storage, not a visible character, but it is the only signal that tells a reader where the text ends. Any function that walks the array has to stop there, which is the central idea of the rest of this article.

A pointer that points to the first element can be moved forward to point to the next element. Each step forward moves the pointer past one element, and reading the value the pointer refers to gives the element at that position. Applying ++p advances the pointer by one element of its target type. For a pointer to char, that is one character, so a single ++p moves the pointer from one character to the character that follows it.

Each arrow in the diagram is one ++p. The pointer never skips an element, so a loop that repeats the step and reads the value at each position visits every character in turn, from the first one to the last one. Notice that the step is measured in elements of the target type, not in a fixed count of raw memory units; for char, the element and the character are the same thing.

The function takes a pointer to char and a character x, and returns how many times x appears in the array. Its first line handles the case where the pointer points to no array at all. Its loop header is shown below, with an empty initializer, so the pointer keeps the value it was given.

Read the loop carefully. The body checks the element the pointer currently refers to, and the step moves the pointer forward. The only thing that decides when the loop ends is the condition p != nullptr. That condition tests the pointer, not the character it refers to. Keep this in mind, because it determines where the loop actually stops.

A null pointer is a pointer that points to nothing. Using it to read a character would be an error, so the function checks for it before doing anything else. The first line returns zero immediately when there is no array. The loop condition p != nullptr repeats the same test on every pass. A null pointer and a pointer that points at the '\0' terminator are different things: the first points to no array at all, while the second points at a real element of an array, the element that marks its end.

A zero-terminated array has an end marker, so a loop over it should stop when the element it refers to is that zero. The stopping condition must match the array's end marker. The source loop tests the pointer against nullptr instead, and a pointer walking through a char array does not become null when it reaches the terminator. The terminator is an ordinary zero value sitting inside the array, so the test that matters is on the character, not on the pointer.

This corrected version keeps the null guard and separates the two jobs. The null check protects against a pointer that points to nothing. The end-marker check ends the walk at the terminator. The source loop merged these concerns into a single test on the pointer, which is why it does not stop where the array does.

The trace shows the divergence point clearly. With the corrected condition, the count and the position of p agree at every step and the loop halts on the terminator with count equal to 3. With the source condition p != nullptr, nothing changes until p moves past the terminator. The loop would not stop at index 6, because p is still not null there. It would keep advancing into memory beyond the array, and the source does not describe what those reads would return. The count at the moment the terminator is reached is still 3, but the loop has not finished its job, and its result can no longer be trusted.