Pointer Arithmetic in C++

Pointer Arithmetic Program in C++.

BeginnerMemory Management ProgramsExample 2 of 11

pointer-arithmetic.cpp

1#include <iostream>
2using namespace std;
3
4int main() {
5    int arr[] = {10, 20, 30, 40, 50};
6    int* ptr = arr;  // Points to first element
7    
8    cout << "Array elements using pointer arithmetic:" << endl;
9    
10    // Access elements using pointer
11    for (int i = 0; i < 5; i++) {
12        cout << "arr[" << i << "] = " << *(ptr + i) << endl;
13        cout << "Address: " << (ptr + i) << endl;
14    }
15    
16    cout << "\nIncrementing pointer:" << endl;
17    ptr = arr;  // Reset to beginning
18    for (int i = 0; i < 5; i++) {
19        cout << "Value: " << *ptr << ", Address: " << ptr << endl;
20        ptr++;  // Move to next element
21    }
22    
23    cout << "\nDecrementing pointer:" << endl;
24    ptr--;  // Now points to last element
25    for (int i = 0; i < 5; i++) {
26        cout << "Value: " << *ptr << ", Address: " << ptr << endl;
27        ptr--;  // Move to previous element
28    }
29    
30    return 0;
31}

Output

Array elements using pointer arithmetic:
arr[0] = 10
Address: 0x7fff5fbff6a0
arr[1] = 20
Address: 0x7fff5fbff6a4
arr[2] = 30
Address: 0x7fff5fbff6a8
arr[3] = 40
Address: 0x7fff5fbff6ac
arr[4] = 50
Address: 0x7fff5fbff6b0

Incrementing pointer:
Value: 10, Address: 0x7fff5fbff6a0
Value: 20, Address: 0x7fff5fbff6a4
Value: 30, Address: 0x7fff5fbff6a8
Value: 40, Address: 0x7fff5fbff6ac
Value: 50, Address: 0x7fff5fbff6b0

Decrementing pointer:
Value: 50, Address: 0x7fff5fbff6b0
Value: 40, Address: 0x7fff5fbff6ac
Value: 30, Address: 0x7fff5fbff6a8
Value: 20, Address: 0x7fff5fbff6a4
Value: 10, Address: 0x7fff5fbff6a0

What's going on

The program demonstrates pointer arithmetic operations:

Adding integers to pointers (ptr + 1, ptr + 2)

Subtracting integers from pointers (ptr - 1)

Incrementing pointers (ptr++)

Decrementing pointers (ptr--)

Traversing arrays using pointer arithmetic

Pointer arithmetic automatically accounts for data type size.

Header File Used

This header provides:

cout for displaying output

cin for taking input from the user

1#include <iostream>

Understanding Pointer Arithmetic

Arithmetic Concept

Can add/subtract integers to/from pointers

Address changes by data type size

ptr + 1 moves to next element (not next byte)

Respects data type sizes automatically

Key Rule

ptr + n moves n elements forward

Address increases by n × sizeof(dataType)

Example: int* ptr + 1 increases by 4 bytes (if int is 4 bytes)

Adding to Pointers

Basic Addition

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

int* ptr = arr; // Points to arr[0]

*(ptr + 1) // Accesses arr[1] (value 20)

*(ptr + 2) // Accesses arr[2] (value 30)

How it works

ptr + 1: address increases by sizeof(int)

For int (4 bytes): address increases by 4

Points to next element in array

Incrementing Pointers

Increment Operation

ptr++; // Moves to next element

Example

ptr = arr; // Points to arr[0]

ptr++; // Now points to arr[1]

ptr++; // Now points to arr[2]

How it works

ptr++ increments address by sizeof(dataType)

Equivalent to ptr = ptr + 1

Moves pointer to next element

Subtracting from Pointers

Basic Subtraction

*(ptr - 1) // Accesses previous element

Decrement Operation

ptr--; // Moves to previous element

How it works

ptr - 1: address decreases by sizeof(dataType)

ptr--: decrements address by sizeof(dataType)

Moves pointer to previous element

Pointer Arithmetic with Different Types

int (4 bytes)

int* ptr;

ptr + 1 // Increases by 4 bytes

char (1 byte)

char* ptr;

ptr + 1 // Increases by 1 byte

double (8 bytes)

double* ptr;

ptr + 1 // Increases by 8 bytes

Key Point

: Arithmetic automatically accounts for type size.

Traversing Arrays

Using Pointer Arithmetic

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

int* ptr = arr;

for (int i = 0; i < 5; i++) {

}

1cout << *(ptr + i) << endl;  // Access arr[i]

Using Increment

ptr = arr;

for (int i = 0; i < 5; i++) {

ptr++; // Move to next element

}

1cout << *ptr << endl;

When to Use Pointer Arithmetic

Best For

Traversing arrays efficiently

Dynamic memory operations

String manipulation

Implementing data structures

Performance-critical code

Example Scenarios

Iterating through arrays

Processing strings character by character

Dynamic array operations

Linked list traversal

Important Considerations

Array Bounds

Be careful not to go beyond array bounds

ptr + 10 on array of size 5 is invalid

Can cause undefined behavior

Type Safety

Pointer arithmetic respects type size

int* + 1 ≠ char* + 1 (different increments)

Compiler handles size automatically

Pointer Comparison

Can compare pointers (ptr1 < ptr2)

Useful for checking array bounds

Only valid for pointers to same array

return 0;

This ends the program successfully.

PreviousBasic Pointers NextPointer to Pointer