#include <iostream>
using namespace std;
int main() {
int arr[] = {10, 20, 30, 40, 50};
int* ptr = arr; // Points to first element
cout << "Array elements using pointer arithmetic:" << endl;
// Access elements using pointer
for (int i = 0; i < 5; i++) {
cout << "arr[" << i << "] = " << *(ptr + i) << endl;
cout << "Address: " << (ptr + i) << endl;
}
cout << "\nIncrementing pointer:" << endl;
ptr = arr; // Reset to beginning
for (int i = 0; i < 5; i++) {
cout << "Value: " << *ptr << ", Address: " << ptr << endl;
ptr++; // Move to next element
}
cout << "\nDecrementing pointer:" << endl;
ptr--; // Now points to last element
for (int i = 0; i < 5; i++) {
cout << "Value: " << *ptr << ", Address: " << ptr << endl;
ptr--; // Move to previous element
}
return 0;
}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
This program teaches you how to perform Pointer Arithmetic in C++. Pointer arithmetic allows you to perform operations like addition and subtraction on pointers. When you add or subtract integers from pointers, the address changes by the size of the data type, making it perfect for traversing arrays.
1. What This Program Does
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.
2. Header File Used
#include <iostream>
This header provides:
- cout for displaying output
- cin for taking input from the user
3. 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)
4. 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
5. 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
6. 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
7. 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.
8. Traversing Arrays
Using Pointer Arithmetic:
int arr[] = {10, 20, 30, 40, 50}; int* ptr = arr;
for (int i = 0; i < 5; i++) { cout << *(ptr + i) << endl; // Access arr[i] }
Using Increment:
ptr = arr; for (int i = 0; i < 5; i++) { cout << *ptr << endl; ptr++; // Move to next element }
9. 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
10. 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
11. return 0;
This ends the program successfully.
Summary
- Pointer arithmetic: add/subtract integers to/from pointers.
- Address changes by data type size (not by 1 byte).
- ptr + 1 moves to next element, not next byte.
- Increment (ptr++) and decrement (ptr--) move by element size.
- Useful for efficiently traversing arrays.
- Automatically accounts for data type sizes.
- Understanding pointer arithmetic enables efficient array processing.
This program is fundamental for learning efficient array traversal, understanding memory layout, and preparing for advanced pointer operations in C++ programs.