Buggati

1. SDF II(15B11CI211)
EVEN Semester 2025
2nd
Semester , First Year
Jaypee Institute Of Information Technology (JIIT), Noida

2. Lecture 4 – Pointers arithmetic in C++

3. Pointers
✔ Pointers store address of variables or a memory location.
✔ // General syntax
datatype *var_name;
// An example pointer "ptr" that holds address of an integer variable or holds address of a
memory whose value(s) can be accessed as integer values through "ptr"
int *ptr;

4. POINTER ARITHMETIC:
• pointer is an address which is a numeric value; therefore, you can perform arithmetic
operations on a pointer just as you can a numeric value.
• There are four arithmetic operators that can be used on pointers:
1. Increment Operator ++,
2. Decrement Operator --,
3. Addition ,
4. Subtraction
5. Comparison (>, >=, <, <=, ==)

5. POINTER ARITHMETIC:
• When you increment a pointer, it moves to the next memory location based on the size
of the data it points to.
• To understand pointer arithmetic, let us consider that ptr is an integer pointer which
points to the address 1000.
• Assuming 32-bit integers, let us perform the following arithmetic operation on the
pointer—
ptr++
• The ptr will point to the location 1004 because each time ptr is incremented, it will point
to the next integer.
• This operation will move the pointer to next memory location without impacting actual
value at the memory location.

6. Incrementing a Pointer
• We prefer using a pointer in our program instead of an array because the variable
pointer can be incremented, unlike the array name which cannot be incremented
because it is a constant pointer.
• The following program increments the variable pointer to access each succeeding
element of the array −

7. Example
#include <iostream>
using namespace std;
const int MAX = 3;
int main () {
int var[MAX] = {10, 100, 200};
int *ptr;
// let us have array address in pointer.
ptr = var;
for (int i = 0; i < MAX; i++) {
cout << "Address of var[" << i << "] = ";
cout << ptr << endl;
cout << "Value of var[" << i << "] = ";
cout << *ptr << endl;
// point to the next location
ptr++;
}
return 0;
}

8. Output:
• When the above code is compiled and executed, it produces result something as follows—
Address of var[0] = 0xbfa088b0
Value of var[0] = 10
Address of var[1] = 0xbfa088b4
Value of var[1] = 100
Address of var[2] = 0xbfa088b8
Value of var[2] = 200

9. Decrementing a Pointer
The same considerations apply to decrementing a pointer, which decreases its value by the
number of bytes of its data type as shown below −
#include <iostream>
using namespace std;
const int MAX = 3;
int main () {
int var[MAX] = {10, 100, 200};
int *ptr;
// let us have address of the last element in pointer.
ptr = &var[MAX-1];
for (int i = MAX; i > 0; i--) {
cout << "Address of var[" << i << "] = ";
cout << ptr << endl;
cout << "Value of var[" << i << "] = ";
cout << *ptr << endl;
// point to the previous location
ptr--;
}
return 0;
}

10. Output
• When the above code is compiled and executed, it produces result something as
follows −
Address of var[3] = 0xbfdb70f8
Value of var[3] = 200
Address of var[2] = 0xbfdb70f4
Value of var[2] = 100
Address of var[1] = 0xbfdb70f0
Value of var[1] = 10

11. Addition of Integer/Constant to Pointer
• You can add an integer to a pointer but you cannot add a pointer to a
pointer.
• the integer value is first multiplied by the size of the data type to which
the pointer points, and then the result is added to the pointer’s address.
• You have an integer pointer storing the address ptr = 1000.
• When you add the integer 5 to it with the expression ptr = ptr + 5, the
final address stored in ptr will be calculated as follows: 1000 + sizeof(int) *
5, which is equal to 1020.

12. #include <iostream>
using namespace std;
int main() {
int num = 20;
int* ptr = &num;
cout << "Address stored in ptr: " << ptr << endl;
ptr = ptr + 3;
cout << "Adding 3 to ptr: " << ptr << endl;
return 0;
}

13. Subtraction of Integer/constant to Pointer
• If you have an integer pointer storing the address ptr = 1000.
• When you subtract the integer 5 from it with the expression ptr = ptr - 5,
the final address stored in ptr will be calculated as follows: 1000 -
sizeof(int) * 5, which is equal to 980.

14. #include <iostream>
using namespace std;
int main()
{
int num = 100;
int* ptr = &num;
cout << "Address stored in ptr: " << ptr << endl;
ptr = ptr - 2;
cout << "Subtract 2 from ptr: " << ptr << endl;
return 0;
}

15. Subtraction of Two Pointers
• When you subtract two pointers that point to the same data type, the result is
calculated by finding the difference between their addresses and then dividing by
the size of the data type to determine how many elements (not bytes) separate
the two pointers.
• If ptr1 = 1000 and ptr2 = 1004.
• (ptr2 - ptr1), you get a result of 4 bytes, which is the difference in addresses.
• Since the size of an integer is 4 bytes, you divide the address difference by the size
of the data type: (4 / 4), which equals 1. This means there is an increment of 1
integer-sized element between ptr1 and ptr2.
• If you have two pointers that point to the same array, you can subtract one pointer
from the other. This operation yields the number of elements in the array that
separate the two addresses that the pointers refer to.

16. #include <iostream>
using namespace std;
int main() {
int x = 6; // Integer variable declaration
int N = 4;
// Pointer declaration
int *ptr1, *ptr2;
ptr1 = &N; // stores the address of N
ptr2 = &x; // stores the address of x
cout << "ptr1 = " << ptr1 << ", ptr2 = " << ptr2 << endl;
// Subtraction of ptr2 and ptr1
x = ptr2 - ptr1;
cout << "Subtraction of ptr1 & ptr2 is " << x << endl;
return 0;
}
OUTPUT:-
ptr1 = 0x7ffd40979c78, ptr2 = 0x7ffd40979c7c
Subtraction of ptr1 & ptr2 is 1

17. Pointer Comparisons
• Pointers may be compared by using the following operators: ==, !=, <, >, <=, and >=.
• Pointer comparisons are defined only when the pointers have same data type.
Comparison is meaningful when pointers point to elements of the same array.
• If p1 and p2 point to variables that are related to each other, such as elements of the
same array, then p1 and p2 can be meaningfully compared.
• The following program modifies the previous example one by incrementing the variable
pointer so long as the address to which it points is either less than or equal to the address
of the last element of the array, which is &var[MAX - 1] −

18. Example
#include <iostream>
using namespace std;
const int MAX = 3;
int main () {
int var[MAX] = {10, 100, 200};
int *ptr;
// let us have address of the first element in pointer.
ptr = var;
int i = 0;
while ( ptr <= &var[MAX - 1] ) {
cout << "Address of var[" << i << "] = ";
cout << ptr << endl;
cout << "Value of var[" << i << "] = ";
cout << *ptr << endl;
// point to the previous location
ptr++;
i++;
}
return 0;
}

19. Output—
• When the above code is compiled and executed, it produces result
something as follows −
Address of var[0] = 0xbfce42d0
Value of var[0] = 10
Address of var[1] = 0xbfce42d4
Value of var[1] = 100
Address of var[2] = 0xbfce42d8
Value of var[2] = 200

20. #include <iostream>
using namespace std;
int main()
{
int num = 10;
int arr[5] = {6,8,9,45,3};
int* ptr1 = arr;
int* ptr2 = &num;
int* ptr3 = &arr[3];
// comparing
if (ptr1 != ptr2) {
cout << "Both point to different memory location"<<endl;
}
if (ptr1 < ptr2) {
cout << "possible to compare but meaningless"<<endl;
}
if (ptr1 < ptr3) {
cout << "ptr1 is before ptr3";
}
return 0;
}
OUTPUT:-
Both point to different memory location
possible to compare but meaningless
ptr1 is before ptr3

21. References
• https://www.tutorialspoint.com/cplusplus/cpp_pointer_arithmatic.htm
• http://www.infobrother.com/Tutorial/C++/C++-Pointer-Arithmetic
• https://www.learncpp.com/cpp-tutorial/introduction-to-pointers/