Pointer Arithmetic in C

Introduction

Pointer arithmetic is a powerful feature in C that allows you to perform operations on memory addresses. This can be particularly useful when dealing with arrays and dynamic memory allocation. In this tutorial, we will explore the basics of pointer arithmetic, including incrementing, decrementing, and pointer differences.

Basics of Pointer Arithmetic

When you perform arithmetic operations on pointers, the compiler automatically takes into account the size of the data type to which the pointer points. Here are the common operations you can perform with pointers:

• Incrementing a Pointer: Moves the pointer to the next memory location of its type.
• Decrementing a Pointer: Moves the pointer to the previous memory location of its type.
• Pointer Addition/Subtraction: Adds or subtracts a specified number of elements from the pointer.
• Pointer Difference: Determines the number of elements between two pointers.

Incrementing and Decrementing Pointers

When you increment a pointer, it moves to the next memory location of its type. Similarly, decrementing a pointer moves it to the previous memory location.

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

printf("Initial value: %d\n", *ptr);
ptr++;
printf("After increment: %d\n", *ptr);
ptr--;
printf("After decrement: %d\n", *ptr);
                

Initial value: 10
After increment: 20
After decrement: 10
                    

Pointer Addition and Subtraction

You can add or subtract an integer value to/from a pointer. This moves the pointer by that many elements of its type.

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

ptr = ptr + 2;
printf("After adding 2: %d\n", *ptr);
ptr = ptr - 1;
printf("After subtracting 1: %d\n", *ptr);
                

After adding 2: 30
After subtracting 1: 20
                    

Pointer Difference

Pointer difference is used to determine the number of elements between two pointers. It returns the difference as an integer.

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

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

Difference between pointers: 3
                    

Pointer Arithmetic with Different Data Types

The size of the data type to which a pointer points affects pointer arithmetic. For example, if a pointer points to a char, incrementing it will move by 1 byte, but if it points to an int, it will move by 4 bytes (assuming 4 bytes for an int).

char c;
int i;
double d;

char *ptr_c = &c;
int *ptr_i = &i;
double *ptr_d = &d;

printf("Address of c: %p\n", ptr_c);
printf("Address of i: %p\n", ptr_i);
printf("Address of d: %p\n", ptr_d);

ptr_c++;
ptr_i++;
ptr_d++;

printf("After incrementing:\n");
printf("Address of c: %p\n", ptr_c);
printf("Address of i: %p\n", ptr_i);
printf("Address of d: %p\n", ptr_d);
                

Address of c: 0x7ffee2c8d90f
Address of i: 0x7ffee2c8d910
Address of d: 0x7ffee2c8d918

After incrementing:
Address of c: 0x7ffee2c8d910
Address of i: 0x7ffee2c8d914
Address of d: 0x7ffee2c8d920
                    

Conclusion

Pointer arithmetic is a fundamental concept in C programming that provides powerful capabilities for memory manipulation. By understanding how to increment, decrement, add, subtract, and find the difference between pointers, you can effectively manage and traverse arrays, and perform more complex data manipulations.