C++ Pointers
In C++, pointers are variables that store the memory addresses of other
variables.
Address in C++
Every variable we declare in our program has an associated location in the
memory, which we call the memory address of the variable.
If we have a variable var in our program, &var returns its memory address. For
example,
#include <iostream>
using namespace std;
int main()
{
// declare variables
int var1 = 3;
int var2 = 24;
int var3 = 17;
// print address of var1
cout << "Address of var1: "<< &var1 << endl;
// print address of var2
cout << "Address of var2: " << &var2 << endl;
// print address of var3
cout << "Address of var3: " << &var3 << endl;
}
Output
Address of var1: 0x7fff5fbff8ac
Address of var2: 0x7fff5fbff8a8
Address of var3: 0x7fff5fbff8a4
Here, 0x at the beginning represents the address in the hexadecimal form.
Notice that the first address differs from the second by 4 bytes, and the
second address differs from the third by 4 bytes.
The difference is because the size of an int is 4 bytes in a 64-bit system.
Note: You may not get the same results when you run the program. This is
because the address depends on the environment in which the program runs.
C++ Pointers
Here is how we can declare pointers:
int *point_var;
Here, we have declared a variable point_var which is a pointer to an int .
We can also declare pointers in the following way:
int* point_var; // preferred syntax
Assigning Addresses to Pointers
Here is how we can assign addresses to pointers:
int var = 5;
int* point_var = &var;
Here, 5 is assigned to the variable var . And the address of var is assigned to
the point_var pointer with the code point_var = &var .
Note: It is a good practice to initialize pointers as soon as they are declared.
Get the Value from the Address Using Pointers
To get the value pointed by a pointer, we use the * operator. For example:
int var = 5;
// assign address of var to point_var
int* point_var = &var;
// access value pointed by point_var
cout << *point_var << endl; // Output: 5
In the above code, the address of var is assigned to point_var . We have used
the *point_var to get the value stored in that address.
When * is used with pointers, it's called the dereference operator. It operates
on a pointer and gives the value pointed by the address stored in the pointer.
That is, *point_var = var .
Note: In C++, point_var and *point_var are completely different. We cannot do
something like *point_var = &var; . Here, point_var is a pointer that stores the
address of variable it points to while *point_var returns the value stored at the
address pointed by point_var .
Example 1: Working of C++ Pointers
#include <iostream>
using namespace std;
int main() {
int var = 5;
// store address of var
int* point_var = &var;
// print value of var
cout << "var = " << var << endl;
// print address of var
cout << "Address of var (&var) = " << &var << endl
<< endl;
// print pointer point_var
cout << "point_var = " << point_var << endl;
// print the content of the address point_var points to
cout << "Content of the address pointed to by point_var (*point_var) = " <<
*point_var << endl;
return 0;
}
Output
var = 5
Address of var (&var) = 0x61ff08
point_var = 0x61ff08
Content of the address pointed to by point_var (*point_var) = 5
Working of C++ pointers
Changing Value Pointed by Pointers
If point_var points to the address of var , we can change the value of var by
using *point_var .
For example,
int var = 5;
int* point_var = *var;
// change value at address point_var
*point_var = 1;
cout << var << endl; // Output: 1
Here, point_var and &var have the same address; the value of var will also be
changed when *point_var is changed.
Example 2: Changing Value Pointed by Pointers
#include <iostream>
using namespace std;
int main() {
int var = 5;
// store address of var
int* point_var = &var;
// print var
cout << "var = " << var << endl;
// print *point_var
cout << "*point_var = " << *point_var << endl
<< endl;
cout << "Changing value of var to 7:" << endl;
// change value of var to 7
var = 7;
// print var
cout << "var = " << var << endl;
// print *point_var
cout << "*point_var = " << *point_var << endl
<< endl;
cout << "Changing value of *point_var to 16:" << endl;
// change value of var to 16
*point_var = 16;
// print var
cout << "var = " << var << endl;
// print *point_var
cout << "*point_var = " << *point_var << endl;
return 0;
}
Output
var = 5
*point_var = 5
Changing value of var to 7:
var = 7
*point_var = 7
Changing value of *point_var to 16:
var = 16
*point_var = 16
Here point_var holds the address of var , and by
dereferencing point_var with *point_var , we can access and modify the value
stored at that address, which in turn affects the original variable var.
Common Mistakes When Working with Pointers
Suppose we want a pointer point_var to point to the address of var . Then,
int var = 5;
// Wrong!
// point_var is an address but var is not
int* point_var = var;
// Wrong!
// &var is an address
// *point_var is the value stored in &var
*point_var = &var;
// Correct!
// point_var is an address and so is &var
point_var = &var;
// Correct!
// both *point_var and var are values
*point_var = var;
C++ Pointers and Arrays
In C++, Pointers are variables that hold addresses of other variables. Not only
can a pointer store the address of a single variable, it can also store the
address of cells of an array.
Consider this example:
int *ptr;
int arr[5];
// store the address of the first
// element of arr in ptr
ptr = arr;
Here, ptr is a pointer variable while arr is an int array. The code ptr =
arr; stores the address of the first element of the array in variable ptr .
Notice that we have used arr instead of &arr[0] . This is because both are the
same. So, the code below is the same as the code above.
int *ptr;
int arr[5];
ptr = &arr[0];
The addresses for the rest of the array elements are given
by &arr[1] , &arr[2] , &arr[3] , and &arr[4] .
Point to Every Array Elements
Suppose we need to point to the fourth element of the array using the same
pointer ptr .
Here, if ptr points to the first element in the above example then ptr + 3 will
point to the fourth element. For example,
int *ptr;
int arr[5];
ptr = arr;
ptr + 1 is equivalent to &arr[1];
ptr + 2 is equivalent to &arr[2];
ptr + 3 is equivalent to &arr[3];
ptr + 4 is equivalent to &arr[4];
Similarly, we can access the elements using the single pointer. For example,
// use dereference operator
*ptr == arr[0];
*(ptr + 1) is equivalent to arr[1];
*(ptr + 2) is equivalent to arr[2];
*(ptr + 3) is equivalent to arr[3];
*(ptr + 4) is equivalent to arr[4];
Suppose if we have initialized ptr = &arr[2]; then
ptr - 2 is equivalent to &arr[0];
ptr - 1 is equivalent to &arr[1];
ptr + 1 is equivalent to &arr[3];
ptr + 2 is equivalent to &arr[4];
Working of C++
Pointers with Arrays
Note: The address between ptr and ptr + 1 differs by 4 bytes. It is
because ptr is a pointer to an int data. And, the size of int is 4 bytes in a 64-
bit operating system.
Similarly, if pointer ptr is pointing to char type data, then the address
between ptr and ptr + 1 is 1 byte. It is because the size of a character is 1
byte.
Example 1: C++ Pointers and Arrays
// C++ Program to display address of each element of an array
#include <iostream>
using namespace std;
int main()
{
float arr[3];
// declare pointer variable
float *ptr;
cout << "Displaying address using arrays: " << endl;
// use for loop to print addresses of all array elements
for (int i = 0; i < 3; ++i)
{
cout << "&arr[" << i << "] = " << &arr[i] << endl;
}
// ptr = &arr[0]
ptr = arr;
cout<<"\nDisplaying address using pointers: "<< endl;
// use for loop to print addresses of all array elements
// using pointer notation
for (int i = 0; i < 3; ++i)
{
cout << "ptr + " << i << " = "<< ptr + i << endl;
}
return 0;
}
Run Code
Output
Displaying address using arrays:
&arr[0] = 0x61fef0
&arr[1] = 0x61fef4
&arr[2] = 0x61fef8
Displaying address using pointers:
ptr + 0 = 0x61fef0
ptr + 1 = 0x61fef4
ptr + 2 = 0x61fef8
In the above program, we first simply printed the addresses of the array
elements without using the pointer variable ptr .
Then, we used the pointer ptr to point to the address of a[0] , ptr + 1 to point
to the address of a[1] , and so on.
In most contexts, array names decay to pointers. In simple words, array
names are converted to pointers. That's the reason why we can use pointers
to access elements of arrays.
However, we should remember that pointers and arrays are not the same..
Example 2: Array name used as pointer
// C++ Program to insert and display data entered by using pointer notation.
#include <iostream>
using namespace std;
int main() {
float arr[5];
// Insert data using pointer notation
cout << "Enter 5 numbers: ";
for (int i = 0; i < 5; ++i) {
// store input number in arr[i]
cin >> *(arr + i) ;
// Display data using pointer notation
cout << "Displaying data: " << endl;
for (int i = 0; i < 5; ++i) {
// display value of arr[i]
cout << *(arr + i) << endl ;
return 0;
}
Output
Enter 5 numbers: 2.5
3.5
4.5
5
2
Displaying data:
2.5
3.5
4.5
5
2
Here,
1. We first used the pointer notation to store the numbers entered by the user
into the array arr .
cin >> *(arr + i) ;
This code is equivalent to the code below:
cin >> arr[i];
Notice that we haven't declared a separate pointer variable, but rather we are
using the array name arr for the pointer notation.
As we already know, the array name arr points to the first element of the
array. So, we can think of arr as acting like a pointer.
2. Similarly, we then used for loop to display the values of arr using pointer
notation.
cout << *(arr + i) << endl ;
This code is equivalent to
cout << arr[i] << endl ;
