Pointer Arithmetic Essentials

The Core Principle of Pointer Arithmetic

When you add 1 to an integer, the value increases by one. When you add 1 to a pointer, the compiler does something much smarter. Instead of just incrementing the memory address by a single byte, it advances the pointer by the size of the data type it points to.

This ensures that the pointer, after the operation, points to the next element in a sequence, regardless of whether those elements are chars (1 byte), ints (often 4 bytes), or complex structs.

The general rule for adding an integer i to a pointer p is:
$\text{new\_address}=\text{current\_address}+(i\times \text{sizeof}(\ast p))$
This same scaled logic applies to all arithmetic operations on pointers.

Pointer Arithmetic Operations

Based on the reading, let's summarize the four key arithmetic operations. Assume int *p; and int i;.

1. Increment (p++ or ++p): Moves the pointer p forward to point to the next int element. The address increases by sizeof(int).
2. Decrement (p-- or --p): Moves the pointer p backward to point to the previous int element. The address decreases by sizeof(int).
3. Addition (p + i): Computes a new address that is i elements after p. The result is p's address plus i * sizeof(int). Note that p = p + i or p += i modifies p.
4. Subtraction (p - i): Computes a new address that is i elements before p. The result is p's address minus i * sizeof(int). p = p - i or p -= i modifies p.
5. Pointer Difference (p2 - p1): This is a special case. When you subtract two pointers (that point into the same array or memory block), the result is not the difference in bytes. Instead, it's the number of elements between them. The result is a signed integer type called ptrdiff_t (defined in <stddef.h>).

For example, if p1 points to array[2] and p2 points to array[5], then p2 - p1 will be 3.

int int_array[] = {10, 20, 30, 40, 50};
double dbl_array[] = {1.1, 2.2, 3.3, 4.4, 5.5};

int *ip = &int_array[1];       // ip points to 20, let's say at address 0x1004
double *dp = &dbl_array[1];    // dp points to 2.2, let's say at address 0x2008

Operator Precedence: *p++, *++p, and ++*p

Things get more interesting when we combine the dereference operator (*) with increment/decrement operators. These compact expressions are extremely common in C code. Understanding them requires knowing about operator precedence and associativity.

Both * (dereference) and ++ (increment) are unary operators with the same precedence. When operators have the same precedence, the compiler uses their associativity to decide the order of evaluation. For these operators, the associativity is right-to-left.

Let's break down the common idioms:

1. *p++ (Post-increment pointer)

   • Associativity is right-to-left, so ++ is associated with p.
   • Because it's a post-increment (p++), the original value of p is used in the expression first.
   • Action: The pointer p is dereferenced to get the value. After the entire expression is evaluated, p is incremented to point to the next element.
   • In short: Get the value, then move the pointer.

2. *++p (Pre-increment pointer)

   • Associativity is right-to-left, so ++ is associated with p.
   • Because it's a pre-increment (++p), p is incremented first.
   • Action: The pointer p is incremented to point to the next element. Then, the new address is dereferenced to get the value.
   • In short: Move the pointer, then get the value.

3. ++*p (Increment value)

   • Here, *p is evaluated first (right-to-left). This gets the value at the address p is pointing to.
   • The ++ operator then increments this value.
   • Action: The value that p points to is incremented. The pointer p itself does not move.
   • In short: Get the value and increment it.

The following videos provide excellent, detailed walkthroughs of these concepts.

A Practical Application: Calculating Memory "Stride"

In your work with communication protocols and data serialization (e.g., parsing SOME/IP packets or CAN frames), you often deal with raw data buffers where different fields are laid out contiguously. Pointer arithmetic is the natural tool for navigating such structures.

A key concept here is the "stride" of an array—the number of bytes between the start of one element and the start of the next. For an array int arr[], the stride is simply sizeof(int).

How would you calculate this stride programmatically using pointers? You might think to do this:
int stride = &arr[1] - &arr[0]; // This is WRONG

Because of pointer arithmetic, this subtraction yields the number of elements between the two pointers, which will always be 1.

To get the stride in bytes, you must first cast the pointers to a type with a size of 1, like char*. This effectively bypasses the scaled arithmetic.

int arr[10];
int stride_in_bytes = (char*)&arr[1] - (char*)&arr[0];
// stride_in_bytes will be 4 on a system with 4-byte integers.

This technique is powerful for inspecting the memory layout of data structures and is a practical application of pointer casting combined with arithmetic. You can find more on this in the "Char Star Pointers" and "Stride of an Array" sections of the "Chapter 12. Pointer Arithmetic" resource (LINK).

Conclusion

In this lesson, we formalized the rules of pointer arithmetic, a critical tool for high-performance C programming.

Key Takeaways:

• Pointer arithmetic is always scaled by the size of the data type the pointer points to (sizeof(*ptr)).
• The valid operations are adding/subtracting an integer to a pointer (p + i, p - i, p++, p--) and subtracting two pointers (p2 - p1).
• Subtracting two pointers gives the number of elements between them, not the byte offset.
• Expressions like *p++ and *++p are common idioms whose behavior depends on operator precedence and associativity (right-to-left).
  • *p++: Use value, then increment pointer.
  • *++p: Increment pointer, then use value.
  • ++*p: Increment the value pointed to.

Now that we have established how to move pointers through memory in a structured way, we are ready for our next lesson. We will explore the deep and fundamental relationship between pointers and arrays, and you will see why the expression arr[i] is just syntactic sugar for *(arr + i).