When iterating forward through an array in C, the standard pattern is straightforward: initialize a `size_t` index at 0, check that it is less than the count, and increment it. However, attempting to mirror this logic for a backward iteration often leads to subtle bugs. A common mistake is to initialize the index at `count - 1` and check if it is greater than or equal to 0. Because `size_t` is an unsigned type, the condition `i >= 0` is always true (tautological), which can lead to infinite loops or out-of-bounds memory access. Furthermore, if the count is 0, the expression `count - 1` wraps around to the maximum possible value for that type (`SIZE_MAX`), causing immediate errors.
Alternative solutions, such as switching to a signed integer type like `ssize_t`, can work but introduce their own complexities. Signed integers can cause issues during implicit type conversions in C expressions, and `ssize_t` is not standard on all platforms (such as Windows). Additionally, on 32-bit systems, using signed integers for large buffers can lead to promotion or truncation problems. These workarounds often result in overcomplicated loop headers that require careful inspection to ensure the logic is correct, making the code harder to maintain and more prone to human error.
David Priver proposes a cleaner, idiomatic solution that avoids these pitfalls by using the post-decrement operator within the loop's initialization and condition. The pattern `for (size_t i = count; i--; )` initializes `i` to the total count. The post-decrement `i--` is evaluated as part of the loop's condition; it decrements the value but returns the value as it was *before* the decrement. This ensures that the first iteration uses `count - 1` (the last valid index), and the loop terminates when `i` was 0 before the decrement. Because unsigned wrap-around is well-defined in C, the loop safely terminates when `i` wraps from 0 to `SIZE_MAX` after the final iteration. This approach remains simple, readable, and avoids the need for signed type conversions.