C++ pointer arithmetic lets you directly navigate memory by adding or subtracting offsets to pointers. This article explains how the syntax works, when it is safe, and how it interacts with arrays and standard library components.
Used carefully, pointer arithmetic can make low-level code fast and expressive. Used incorrectly, it can introduce subtle bugs and security issues, so understanding the rules is essential.
| Operation | Effect on Pointer | Result Type | Valid When... |
|---|---|---|---|
| ptr + n | Moves forward by n elements | Same pointer type | Within allocated object or one past last element |
| ptr - n | Moves backward by n elements | Same pointer type | Result remains inside the same array |
| ptr2 - ptr1 | Computes distance between elements | ptrdiff_t | Both point into the same array or one past the end |
| ++ptr and ptr++ | Advances pointer by one element | Same pointer type | Pointer is not at end of bounds |
| --ptr and ptr-- | Moves backward by one element | Same pointer type | Pointer is not before the start |
Understanding Pointer Arithmetic Rules
Pointer arithmetic operates in units of the pointed-to type size, not raw bytes. Adding 1 to an int* moves the address forward by sizeof(int) bytes. This scaling makes array indexing intuitive because arr[i] is defined as *(arr + i).
The language defines valid pointer positions one past the end of an array, but dereferencing that position is undefined behavior. Mixing pointer types or performing arithmetic outside object bounds usually leads to fragile code and hard-to-diagnose bugs.
Arithmetic with Arrays
Arrays and pointers are closely related in C++. When you pass an array to a function, it typically decays to a pointer to its first element, and indexing naturally maps to pointer arithmetic.
Bounds and Indexing
Valid indices for an array of size N are 0 to N-1, while one-past-the-end index N is allowed for comparison but not for dereferencing. Using indices outside this range leads to out-of-bounds access and undefined behavior.
Pointer Arithmetic in Function Logic
Functions that walk buffers often use pointer arithmetic to traverse data without repeated index calculations. This style can be efficient, but it shifts responsibility to the programmer to keep pointers within valid memory regions.
Standard library algorithms such as std::fill and memcpy rely on pointer-like iteration internally. Understanding how arithmetic affects traversal helps you interface correctly with these routines and reason about their complexity.
Safety and Best Practices
Raw pointer arithmetic is powerful but low-level. Prefer abstractions such as std::span, iterators, and containers when possible, because they enforce bounds and lifetime semantics.
When you must use arithmetic, always ensure that pointers stay within the same object or one past the end, avoid signed overflow, and do not create aliases that violate strict aliasing rules. Document assumptions about alignment and lifetime clearly.
Key Takeaways for C++ Pointer Arithmetic
- Pointer arithmetic moves in steps equal to the size of the pointed-to type, not single bytes.
- Adding or subtracting is well-defined only within an array or one past the last element.
- Dereferencing out-of-bounds pointers, even after simple arithmetic, is undefined behavior.
- Prefer standard library abstractions such as iterators and std::span for safer traversal.
- Use pointer arithmetic selectively in performance-critical sections when bounds are provably safe.
FAQ
Reader questions
Can pointer arithmetic be used with any data type in C++?
Pointer arithmetic is defined for pointers to objects and arrays, and the offset is scaled by the size of the pointed-to type. It works reliably with fundamental types, structures, and arrays, but you must ensure that the resulting pointer remains inside the same object or one past the end, and that alignment stays valid for the target type.
What happens if I add a number that points outside the array in my program?
Adding an offset that moves the pointer outside the array bounds produces undefined behavior if you dereference the result, even for reading. Comparisons and address calculations may still be valid, so keep arithmetic within logical ranges and validate indices before access.
How is pointer arithmetic related to array indexing in C++?
The expression arr[i] is defined by the standard as *(arr + i), so pointer arithmetic underlies array indexing at the language level. This equivalence means that understanding how addresses change with addition helps you predict performance and behavior of indexed code.
Should I use pointer arithmetic in new C++ projects instead of modern alternatives?
Modern C++ offers std::span, iterators, and containers that provide safer traversal with less risk of off-by-one errors. Use raw pointer arithmetic only when profiling shows a clear hotspot and you can guarantee correctness, or when interfacing directly with low-level APIs.