Pointer Arithmetic in C

Hello Everyone, In this article, we will cover the concept of Pointer Arithmetic in C Programming. You will learn here how to use pointers to navigate through arrays, access different memory locations, and perform calculations, and different types of pointers in c. Whether you’re new to C or have some experience, this guide will help you to understand concet of Pointer Arithmetic in C effectively. Let’s get started.

Pointer arithmetic in C is the process of manipulating memory addresses using pointers. Pointers are variables that store the memory address of another variable or data type. In C, you can perform arithmetic operations on pointers, such as addition, subtraction, comparison, and increment/decrement, to access or modify the elements in an array or memory block.

Main Pointer Arithmetic Operations in C

Addition:

When you add an integer value to a pointer, the pointer moves forward by the number of bytes equal to the value multiplied by the size of the data type the pointer is pointing to. This is called “scaling” because the pointer moves in “steps” of the size of the data type.

For example, if you have an integer pointer int *ptr, and you add 2 to it, the pointer will move forward by 2 * sizeof(int) bytes in memory (assuming sizeof(int) is 4 bytes, the pointer will move forward by 8 bytes).

Subtraction:

Pointer subtraction is similar to addition, but the pointer moves backward in memory. If you subtract an integer value from a pointer, the pointer moves back by the number of bytes equal to the value multiplied by the size of the data type the pointer is pointing to.

For example, if you have an integer pointer int *ptr, and you subtract 1 from it, the pointer will move back by 1 * sizeof(int) bytes in memory (assuming sizeof(int) is 4 bytes, the pointer will move back by 4 bytes).

Increment and Decrement:

You can use the increment (++) and decrement (–) operators to move the pointer forward or backward by one element. This is equivalent to adding or subtracting 1 in pointer arithmetic.

For example, if you have an integer pointer int *ptr, you can increment it using ptr++ to move it forward by sizeof(int) bytes, or decrement it using ptr– to move it back by sizeof(int) bytes.

Comparison:

You can compare pointers using relational operators, such as ==, !=, <, >, <=, and >=. These operators compare the memory addresses stored in the pointers, not the values they point to.

For example, if you have two integer pointers int *ptr1 and int *ptr2, you can compare them using ptr1 == ptr2 to check if they point to the same memory address, or ptr1 < ptr2 to check if ptr1 points to an address before ptr2 in memory.

Pointer difference:

You can subtract two pointers of the same type to find the number of elements between them. The result is an integer value representing the difference in elements, not bytes.

For example, if you have two integer pointers int *ptr1 and int *ptr2, you can calculate the difference between them using int diff = ptr2 – ptr1;. The result diff will represent the number of integer elements between the two pointers.

Keep in mind that pointer arithmetic is only valid within the same array or memory block. Performing arithmetic that goes beyond the bounds of an array or memory block leads to undefined behavior and can cause errors or crashes in your program.

Here’s a C code example that demonstrates the five pointer arithmetic concepts mentioned above:

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr1, *ptr2;

    // Assigning the address of the first element of the array to ptr1
    ptr1 = arr;

    // 1. Addition
    ptr2 = ptr1 + 2; // ptr2 points to the third element in the array (30)
    printf("Addition: *ptr2 = %d\\n", *ptr2);

    // 2. Subtraction
    ptr2 = ptr2 - 1; // ptr2 points to the second element in the array (20)
    printf("Subtraction: *ptr2 = %d\\n", *ptr2);

    // 3. Increment and Decrement
    ptr2++; // ptr

Pointer Arithmetic in C with Examples

Pointer arithmetic in C allows you to perform arithmetic operations on pointers to manipulate memory addresses. It is often used to traverse and access elements in arrays or memory blocks. In this explanation, I’ll provide examples and code snippets to illustrate the main pointer arithmetic concepts in C.

Addition:

When you add an integer value to a pointer, the pointer moves forward by a number of bytes equal to the value multiplied by the size of the data type the pointer is pointing to.

Example:

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr;

    ptr = arr; // ptr points to the first element of the array (10)
    ptr = ptr + 3; // ptr moves forward by 3 * sizeof(int) bytes, pointing to the fourth element (40)

    printf("Addition: *ptr = %d\\n", *ptr); // Output: Addition: *ptr = 40

    return 0;
}

Subtraction:

Subtraction works similarly to addition, but the pointer moves backward in memory.

Example:

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr;

    ptr = arr + 4; // ptr points to the last element of the array (50)
    ptr = ptr - 2; // ptr moves backward by 2 * sizeof(int) bytes, pointing to the third element (30)

    printf("Subtraction: *ptr = %d\\n", *ptr); // Output: Subtraction: *ptr = 30

    return 0;
}

Increment and Decrement:

You can use the increment (++) and decrement (–) operators to move the pointer forward or backward by one element.

Example:

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr;

    ptr = arr; // ptr points to the first element of the array (10)
    ptr++; // ptr moves forward by sizeof(int) bytes, pointing to the second element (20)

    printf("Increment: *ptr = %d\\n", *ptr); // Output: Increment: *ptr = 20

    ptr--; // ptr moves backward by sizeof(int) bytes, pointing back to the first element (10)
    printf("Decrement: *ptr = %d\\n", *ptr); // Output: Decrement: *ptr = 10

    return 0;
}

Comparison:

You can compare pointers using relational operators. These operators compare the memory addresses stored in the pointers, not the values they point to.

Example:

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr1, *ptr2;

    ptr1 = arr;
    ptr2 = arr + 2;

    if (ptr1 < ptr2) {
        printf("ptr1 is less than ptr2\\n"); // Output: ptr1 is less than ptr2
    } else {
        printf("ptr1 is not less than ptr2\\n");
    }

    return 0;
}

Pointer difference:

You can subtract two pointers of the same type to find the number of elements between them.

Example:

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr1, *ptr2;
    int diff;

    ptr1 = arr;
    ptr2 = arr + 4; // ptr2 points to the last element of the array (50)

    diff = ptr2 - ptr1; // Calculate the difference between ptr2 and ptr1

    printf("Pointer difference: %d\\n", diff); // Output: Pointer difference: 4

    return 0;
}

In this example, we have an integer array arr with five elements. We assign the address of the first element of the array to the pointer ptr1 and the address of the last element to the pointer ptr2. Then, we calculate the difference between ptr2 and ptr1 by subtracting ptr1 from ptr2. The result is the number of integer elements between the two pointers, which is 4 in this case.

These examples demonstrate the main concepts of pointer arithmetic in C. Remember that pointer arithmetic is only valid within the same array or memory block. Performing arithmetic that goes beyond the bounds of an array or memory block leads to undefined behavior and can cause errors or crashes in your program.

TAGGED:Learn C Programming Pointer Arithmetic in C

Share This Article