Pointer arithmetic is one of the most powerful features of the C programming language. Since pointers store memory addresses, C allows certain arithmetic operations to be performed on them. These operations make it possible to move through arrays, access memory locations efficiently, and implement advanced data structures such as linked lists, stacks, queues, and trees.
Unlike normal arithmetic, pointer arithmetic works based on the size of the data type to which the pointer points. When a pointer is incremented or decremented, the address changes by the size of the data type rather than by a single byte.
Understanding pointer arithmetic is essential for writing efficient and optimized C programs.
 

Table of Contents

---

What is Pointer Arithmetic?

Pointer arithmetic refers to performing arithmetic operations on pointer variables to move between memory locations.
When arithmetic operations are performed on a pointer, the compiler automatically adjusts the address according to the size of the data type.

Types of Pointer Arithmetic

1. Pointer Increment (++): Moves the pointer to the next memory location of its data type.
2. Pointer Decrement (–): Moves the pointer to the previous memory location of its data type.
3. Addition of an Integer to a Pointer (+): Moves the pointer forward by a specified number of elements.
4. Subtraction of an Integer from a Pointer (-): Moves the pointer backward by a specified number of elements.
5. Subtraction Between Two Pointers: Calculates the number of elements between two pointers belonging to the same array.

Pointer Increment

The increment operator increases the pointer so that it points to the next element of its data type.
Syntax:

pointer_name++;

Example:

// C program to implement pointer increment
#include stdio.h

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

    int *ptr = arr;

    printf("Before Increment: %d\n", *ptr);

    ptr++;

    printf("After Increment: %d\n", *ptr);

    return 0;
}

Output:

Before Increment: 10
After Increment: 20

Explanation:

1. Initially, the pointer points to the first element of the array.
2. The statement ptr++ moves the pointer to the next integer location.
3. Dereferencing the pointer after increment displays the second element.

Pointer Decrement
The decrement operator decreases the pointer so that it points to the previous memory location of its data type.
Syntax:

pointer_name--;

Example:

// C program to implement Pointer Decrement
#include stdio.h

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

    int *ptr = &arr[2];

    printf("Before Decrement: %d\n", *ptr);

    ptr--;

    printf("After Decrement: %d\n", *ptr);

    return 0;
}

Output:
Before Decrement: 30
After Decrement: 20
Explanation:

1. The pointer initially points to the third element.
2. The decrement operator moves the pointer one element backward.
3. The pointer then points to the second element.

Addition of an Integer to a Pointer

An integer can be added to a pointer to move it forward by a specific number of elements.
Syntax:

pointer_name + n;

Example:

// C program to implement addition 
// of an integer to pointer
#include stdio.h

int main()
{
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    printf("Value = %d", *(ptr + 3));
    return 0;
}

Output:

Value = 40

Explanation:

1. The pointer points to the first array element.
2. ptr + 3 moves the pointer three positions ahead.
3. Dereferencing the result accesses the fourth element.

Subtraction of an Integer from a Pointer

Subtracting an integer from a pointer moves it backward by a specified number of elements.
Syntax:

pointer_name - n;

Example:

// C program to implement subtraction 
// of an integer from a pointer
#include stdio.h

int main()
{
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = &arr[4];
    printf("Current Value: %d\n", *ptr);
    ptr = ptr - 2;
    printf("New Value: %d\n", *ptr);
    return 0;
}

Output:

Current Value: 50
New Value: 30

Explanation:

1. The pointer initially points to the last element.
2. Subtracting 2 moves it back by two positions.
3. The pointer now points to the value 30.

Subtraction Between Two Pointers

Two pointers belonging to the same array can be subtracted to determine the number of elements between them.
Syntax:

pointer1 - pointer2;

Example:

// C program to implement subtraction
// between two pointers
#include stdio.h

int main()
{
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr1 = &arr[1];
    int *ptr2 = &arr[4];
    printf("Difference = %ld", ptr2 - ptr1);
    return 0;
}

Output:

Difference = 3

Explanation:

1. ptr1 points to the second element.
2. ptr2 points to the fifth element.
3. The subtraction result indicates that three elements exist between the two pointer positions.

Pointer Arithmetic with Arrays

Pointer arithmetic is frequently used with arrays because array elements are stored in contiguous memory locations.
Syntax:

*(pointer + index)

Example:

// C program to implement pointer
// arithmetic with arrays
#include stdio.h

int main()
{
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    for(int i = 0; i  5; i++)
    {
        printf("%d ", *(ptr + i));
    }
    return 0;
}

Output:

10 20 30 40 50 

Explanation:

1. The pointer starts at the first element.
2. Each iteration accesses the next element using pointer arithmetic.
3. The entire array is traversed without using array indexing.

Common Mistakes in Pointer Arithmetic

1. Accessing Memory Beyond Array Boundaries: Moving a pointer outside the valid range of an array leads to undefined behavior and may crash the program.

int arr[5];
int *ptr = arr;
ptr = ptr + 10;

2. Performing Arithmetic on a NULL Pointer: A NULL pointer does not point to a valid memory location, so arithmetic operations should never be performed on it.

int *ptr = NULL;
ptr++;

3. Subtracting Pointers from Different Arrays: Pointer subtraction is valid only when both pointers belong to the same array.

int arr1[5];
int arr2[5];
int diff = &arr2[2] - &arr1[1];

4. Dereferencing an Invalid Pointer: Dereferencing a pointer that points outside valid memory causes undefined behavior.

int arr[5];
int *ptr = arr + 6;
printf("%d", *ptr);

5. Assuming All Pointers Move by One Byte: Many beginners assume that incrementing a pointer increases the address by one byte. In reality, the increment depends on the size of the pointed data type.

int *ptr;
ptr++;

For an integer pointer, the address typically increases by 4 bytes.

Conclusion

Pointer arithmetic enables efficient manipulation of memory addresses in C. Operations such as increment, decrement, addition, and subtraction allow programmers to traverse arrays and work directly with memory locations. Since pointer arithmetic depends on the size of the data type, understanding how memory addresses change is essential for avoiding bugs and writing efficient programs. Proper use of pointer arithmetic improves performance and forms the foundation for many advanced programming concepts in C.

Frequently Asked Questions

1. What is pointer arithmetic in C?

Pointer arithmetic is the process of performing arithmetic operations on pointers to move between memory locations.

2. Why does an integer pointer increase by 4 bytes?

An integer typically occupies 4 bytes in memory, so incrementing an integer pointer moves it to the next integer location.

3. Can two pointers be added together?

No. C does not allow the addition of two pointers. Only subtraction between compatible pointers is permitted.

4. Why is pointer arithmetic commonly used with arrays?

Arrays store elements in contiguous memory locations, making pointer arithmetic an efficient way to access and traverse array elements.

5. Can pointer arithmetic be performed on a NULL pointer?

No. Performing arithmetic operations on a NULL pointer results in undefined behavior because it does not reference valid memory.