Pointer arithmetic in C tutorial

Pointer arithmetic in C refers to the manipulation of pointers using arithmetic operations.

It allows you to navigate through arrays and manipulate memory addresses. Pointer arithmetic operates on data types and scales operations based on the size of the data type the pointer references.

1. Basics of Pointer Arithmetic

In C, pointers can be incremented, decremented, and subtracted, allowing you to move between memory locations.

The arithmetic operations adjust based on the size of the data type the pointer is referencing.

2. Incrementing a Pointer

When you increment a pointer, it points to the next memory location of the data type it references. For example, if you have an int pointer and increment it, it will move to the next int (typically 4 bytes forward).

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40};
    int *ptr = arr;

    printf("Initial address: %p, Value: %d\n", (void*)ptr, *ptr);
    ptr++; // Move to the next element
    printf("After incrementing, address: %p, Value: %d\n", (void*)ptr, *ptr);

    return 0;
}

Explanation:

• ptr initially points to the first element of arr.
• ptr++ increments the pointer to point to the next int (4 bytes forward).

Output:

Initial address: 0x... (address of arr[0]), Value: 10
After incrementing, address: 0x... (address of arr[1]), Value: 20

3. Decrementing a Pointer

When you decrement a pointer, it moves to the previous memory location of its data type.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40};
    int *ptr = &arr[2]; // Start at arr[2]

    printf("Initial address: %p, Value: %d\n", (void*)ptr, *ptr);
    ptr--; // Move to the previous element
    printf("After decrementing, address: %p, Value: %d\n", (void*)ptr, *ptr);

    return 0;
}

Explanation:

• ptr initially points to arr[2].
• ptr– moves the pointer back by one int (4 bytes), so it now points to arr[1].

Output:

Initial address: 0x... (address of arr[2]), Value: 30
After decrementing, address: 0x... (address of arr[1]), Value: 20

4. Adding an Integer to a Pointer

You can add an integer value to a pointer, which moves the pointer by that number of elements.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;

    printf("Initial address: %p, Value: %d\n", (void*)ptr, *ptr);
    ptr = ptr + 3; // Move 3 elements forward
    printf("After adding 3, address: %p, Value: %d\n", (void*)ptr, *ptr);

    return 0;
}

Explanation:

• ptr + 3 moves ptr by three int elements (12 bytes), so it now points to arr[3].

Output:

Initial address: 0x... (address of arr[0]), Value: 10
After adding 3, address: 0x... (address of arr[3]), Value: 40

5. Subtracting an Integer from a Pointer

You can subtract an integer value from a pointer, moving it back by that number of elements.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = &arr[4]; // Start at arr[4]

    printf("Initial address: %p, Value: %d\n", (void*)ptr, *ptr);
    ptr = ptr - 2; // Move 2 elements back
    printf("After subtracting 2, address: %p, Value: %d\n", (void*)ptr, *ptr);

    return 0;
}

Explanation:

• ptr – 2 moves ptr back by two int elements (8 bytes), so it now points to arr[2].

Output:

Initial address: 0x... (address of arr[4]), Value: 50
After subtracting 2, address: 0x... (address of arr[2]), Value: 30

6. Pointer Difference

You can calculate the difference between two pointers, which gives the number of elements between them.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr1 = &arr[1];
    int *ptr2 = &arr[4];

    int diff = ptr2 - ptr1;
    printf("Difference between ptr2 and ptr1: %d elements\n", diff);

    return 0;
}

Explanation:

• ptr2 – ptr1 calculates the number of int elements between ptr1 and ptr2, which is 3.

Output:

Difference between ptr2 and ptr1: 3 elements

7. Iterating Over an Array with Pointer Arithmetic

Using pointer arithmetic, you can iterate over an array by incrementing a pointer.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;

    for (int i = 0; i < 5; i++) {
        printf("Element %d: %d\n", i, *ptr);
        ptr++;
    }

    return 0;
}

Explanation:

• The pointer ptr starts at arr[0] and increments with each loop iteration to move through the array elements.

Output:

Element 0: 10
Element 1: 20
Element 2: 30
Element 3: 40
Element 4: 50

8. Using Pointers with Multi-dimensional Arrays

When working with multi-dimensional arrays, pointer arithmetic can be used to access elements. For example, a 2D array can be thought of as a series of arrays in contiguous memory.

#include <stdio.h>

int main() {
    int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int *ptr = &matrix[0][0];

    for (int i = 0; i < 6; i++) {
        printf("Element %d: %d\n", i, *(ptr + i));
    }

    return 0;
}

Explanation:

• ptr points to the first element of matrix.
• The loop accesses elements by incrementing ptr, treating the 2D array as a single 1D array.

Output:

Element 0: 1
Element 1: 2
Element 2: 3
Element 3: 4
Element 4: 5
Element 5: 6

9. Character Pointer Arithmetic

Pointer arithmetic works similarly with char arrays (strings), moving one byte at a time.

#include <stdio.h>

int main() {
    char str[] = "Hello";
    char *ptr = str;

    while (*ptr != '\0') {
        printf("%c ", *ptr);
        ptr++;
    }
    printf("\n");

    return 0;
}

Explanation:

• ptr points to each character in str and increments until it reaches the null terminator (‘\0').

Output:

H e l l o 

10. Summary Table of Pointer Arithmetic Operations

Complete Example: Array Manipulation with Pointer Arithmetic

This example demonstrates using pointer arithmetic to calculate the sum and average of an array.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 

50};
    int size = sizeof(arr) / sizeof(arr[0]);
    int *ptr = arr;
    int sum = 0;

    for (int i = 0; i < size; i++) {
        sum += *ptr; // Dereference pointer to get value
        ptr++;       // Move to the next element
    }

    float average = (float)sum / size;

    printf("Sum: %d\n", sum);
    printf("Average: %.2f\n", average);

    return 0;
}

Explanation:

• ptr is initially set to point to arr[0].
• In each iteration, the value at ptr is added to sum, and ptr is incremented to move to the next element.
• After the loop, sum contains the total, and average is calculated.

Output:

Sum: 150
Average: 30.00

Pointer arithmetic provides a powerful way to work with arrays and memory locations in C