C++ Pointer Arithmetic

In C++, pointer variables are used to store the addresses of other

variables, functions, structures, and even other pointers and we can use
these pointers to access and manipulate the data stored at that address.
Pointer arithmetic means performing arithmetic operations on pointers.
It refers to the operations that are valid to perform on
pointers. Following are the arithmetic operations valid on pointers in
C++:
1. Incrementing and Decrementing Pointers
2. Addition of Constant to Pointers
3. Subtraction of Constant from Pointers
4. Subtraction of Two Pointers of the Same Type
5. Comparison of Pointers
We will explore all the operations listed above in detail with examples.
Prerequisite: To understand pointer arithmetic in C++, we should
know Pointers in C++.
1. Incrementing and Decrementing Pointer in C++
Incrementing or decrementing a pointer will make it refer to the address
of the next or previous data in the memory. This process differs from
incrementing and decrementing numeric data.
For example, when we increment or decrement a numeric data, its value
is incremented or decremented by 1. However, incrementing or
decrementing a pointer, instead of increasing or decreasing by 1,
the address increases or decreases by 1 multiplied by the size of the
data type it is pointing to. (one of the reasons why the pointer
declaration requires the information about the type of data it is pointing
to)
Incrementing a Pointer
Incrementing a pointer will depend on the type of variable address stored
in the pointer. If the pointer stored the address of the integer type
variable then the size of the integer pointer can be 4 or 8 bytes
depending upon the 32-bit machine or 64-bit machine respectively. So,
now if we increment an integer type variable it will be incremented by 4
bytes or 8 bytes depending upon its size.
For example, If a pointer holds the address 1000 and we increment the
pointer, then the pointer will be incremented by 4 or 8 bytes (size of the
integer), and the pointer will now hold the address 1004.
Decrementing a Pointer
When we apply a decrement operation on the pointer then the pointer is
decremented by 4 or 8 bytes depending upon the machine.
For example, If a pointer holds the address 1004 and we decrement the
pointer, then the pointer will be decremented by 4 or 8 bytes (size of the
integer), and the pointer will now hold the address 1000.
Example of Pointer Increment and Decrement
The below C++ program demonstrates the increment and decrement of a
pointer.
C++
// CPP program to demonstrate the incrementy and
decrement
// of a pointer
#include <iostream>
using namespace std;

int main()
{

int num = 27;

// Storing address of num in num_pointer
int* num_pointer = &num;

// Print size of int

cout << "Size of int: " << sizeof(int) << endl;

// Print the address stored at num_pointer

cout << "Before Increment: " << num_pointer <<
endl;
// Increment pointer
num_pointer++;

cout << "After Increment: " << num_pointer <<

endl;

// Print the address stored at num_pointer

cout << "Before Decrement: " << num_pointer <<
endl;
// Decrement pointer
num_pointer--;
 cout << "After Decrement: " << num_pointer <<
endl;

return 0;
}

Output
Size of int: 4
Before Increment: 0x7ffe3e7f56d4
After Increment: 0x7ffe3e7f56d8
Before Decrement: 0x7ffe3e7f56d8
After Decrement: 0x7ffe3e7f56d4

Explanation
We have subtracted ‘1’ from pointer ptr which stored the address of
variable ‘num’. While subtraction firstly ‘1’ is multiplied by the size of
the integer which is 4 bytes and then subtracted from the pointer.
In the same way, this will be applicable to other data types such as float,
double, char, etc.
Refer to the article to learn how to access elements of an array using
pointers.
2. Addition of Constant to Pointers
We can add integer values to Pointers and the pointer is adjusted based
on the size of the data type it points to. For example, if an integer pointer
stores the address 1000 and we add the value 5 to the pointer, it will
store the new address as:
1000 + (5 * 4(size of an integer)) = 1020
Example
The below C++ code demonstrates the addition of a constant to a
pointer.
C++
// CPP program to demonstrate the addition of a
constant to
// a pointer
#include <iostream>
using namespace std;

int main()
{

int num = 20;

int* ptr = &num;

cout << "Address stored in ptr: " <<ptr << endl;

// Adding the integer value 1 to the pointer ptr

ptr = ptr + 1;
cout << "Adding 1 to ptr: " << ptr << endl;

// Adding the integer value 2 to the pointer ptr

ptr = ptr + 2;
cout << "Adding 2 to ptr: " << ptr << endl;

return 0;
}

Output
Address stored in ptr: 0x7ffdb8634a94
Adding 1 to ptr: 0x7ffdb8634a98
Adding 2 to ptr: 0x7ffdb8634aa0
Explanation
We have initialized a variable of integer type and then initialized a
pointer ‘ptr’ of integer type with an address of a variable ‘num’. Now,
we print the address stored in pointer ‘ptr’ after that we have
added ‘1’ to ptr and then again print the address stored in ptr. Now we
can see in the output that the ‘4’ is added to ptr instead of ‘1’. This is
because when we add any constant to the pointer, it first multiplies it to
the size of the type of pointer which is ‘integer’ in this case and here it
takes 4 bytes. so, it first multiplies ‘1’ with ‘4’ and then adds the (1*4) to
the pointer. The same will happen when we add 2, (2*4) will be added to
the pointer ‘ptr’.
3. Subtraction of Constant from Pointers
We can also subtract a constant from Pointers and it is the same as the
addition of a constant to a pointer. For example, if an integer pointer
stores the address 1000 and we subtract the value 5 from the pointer, it
will store the new address as:
1000 - (5 * 4(size of an integer)) = 980
Example
The below C++ code demonstrates the Subtraction of a constant from a
pointer.
C++
// CPP program to demonstrate the subtraction of a
constant
// from a pointer
#include <iostream>
using namespace std;

int main()
{

int num = 100;

int* ptr = &num;
cout << "Address stored in ptr: " << ptr << endl;
ptr = ptr - 1;
cout << "Subtract 1 from ptr: " << ptr << endl;

return 0;
}
4. Subtraction of Two Pointers of the Same Datatype
The Subtraction of two pointers can be done only when both pointers are
of the same data type. The subtraction of two pointers gives the number
of elements present between the two pointers.
Example
The below C++ code demonstrates the subtraction of two pointers.
C++
// CPP program to demonstrate the subtraction of two
// pointers
#include <iostream>
using namespace std;

int main()
{

int num = 45;

int* ptr1 = &num;

// Adding 4 to ptr1 and stored in ptr2

int* ptr2 = ptr1 + 4;

cout << "Address stored in ptr1:" << ptr1 <<

endl;
cout << "Address stored in ptr2:" << ptr2 <<
endl;

// Subtracting ptr2 from ptr1

cout << "ptr2 - ptr1 = " << ptr2 - ptr1 << endl;

return 0;
}

Output
Address stored in ptr1:0x7ffdd3f5673c
Address stored in ptr2:0x7ffdd3f5674c
ptr2 - ptr1 = 4
5. Comparison of Pointers
In C++, we can perform a comparison between the two pointers using
the relational operators(>, <, >=, <=, ==, !=). We generally use this
operation to check whether the two-pointer as pointing to the same
memory location or not.
Example: Comparing Pointer Variables
C++
// C++ Program to illustrate the pointer comparison
#include <iostream>
using namespace std;

int main()
{
// declaring some pointers
int num = 10;
int* ptr1 = &num;
int** ptr2 = &ptr1;
int* ptr3 = *ptr2;

// comparing equality
if (ptr1 == ptr3) {
cout << "Both point to same memory location";
}
else {
cout << "ptr1 points to: " << ptr1 << endl;
cout << "ptr3 points to: " << ptr3 << endl;
}
return 0;
}

Output
Both point to same memory location
Comparison to NULL
We can compare the pointer of a type to NULL. This operation helps us
to find whether the given pointer points to some memory address or not.
It helps us to control errors such as segmentation faults.
Example
C++
// C++ program to compare the pointer to NULL
#include <iostream>
using namespace std;
int main()
{
int num = 10;
// assigning null in case we dont use pointer
int* ptr = NULL;
ptr = &num;

// checking if the pointer is in use or not

if (ptr == NULL) {
cout << "No value is pointed";
}
else {
cout << "The value pointed is " << *ptr;
}
return 0;
}

Output
The value pointed is 10