Skip to main content

Pointer to a pointer in C

Pointer to pointer

Also known as a double pointer, is a type of pointer in C that holds the address of another pointer. Which can then be used to access the value stored at the memory location pointed to by the pointer.

data_type **ptr_ptr;

Here, data_type is the type of the data that the pointer is pointing to.

Example

#include <stdio.h>

// Function that takes a pointer to an int
void increment(int *num)
{
(*num)++; // dereference the pointer and increment the value
}

int main()
{
int num = 0;

printf("num = %d\n", num); // prints "num = 0"

increment(&num); // pass a pointer to the "num" variable

printf("num = %d\n", num); // prints "num = 1"

return 0;
}
Output:

Explanation

  • We declare an integer variable x, a pointer to an integer p, and a pointer to a pointer to an integer q.
  • We initialize p to point to the address of x, and q to point to the address of p.
  • We then print out the addresses and values of x, p, and q, and demonstrate how to access the values of x using both p and q.

Output:

Address of x = 0x7ffeee811ebc
Value of x = 10
Address of p = 0x7ffeee811ec0
Value of p = 0x7ffeee811ebc
Address of q = 0x7ffeee811ec8
Value of q = 0x7ffeee811ec0
Value at p = 10
Value at q = 10

As we can see, by using the pointer to a pointer, we can access the value of x indirectly, by first dereferencing q to get the address of p, and then dereferencing p to get the value of x.

Example - two-dimensional arrays using double pointers

#include <stdio.h>
#include <stdlib.h>

int main()
{
int rows, cols, i, j;

printf("Enter number of rows and columns: ");
scanf("%d %d", &rows, &cols);

// Allocate memory for the rows
int **arr = (int **)malloc(rows * sizeof(int *));

// Allocate memory for the columns of each row
for (i = 0; i < rows; i++)
{
arr[i] = (int *)malloc(cols * sizeof(int));
}

// Populate the array with values
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
arr[i][j] = i * j;
}
}

// Print the array
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}

// Free memory
for (i = 0; i < rows; i++)
{
free(arr[i]);
}
free(arr);

return 0;
}
Output:

Explanation

  • We first ask the user to input the number of rows and columns for the array.
  • We then allocate memory for the rows using a pointer to a pointer int **arr, and then allocate memory for the columns of each row using a loop that runs for the number of rows.
  • We then populate the array with some values, and finally print out the array.
  • After we're done using the array, we free the memory allocated for the rows and the array itself using free().

When to use pointer to pointer

  • Dynamic allocation of two-dimensional arrays using pointers to pointers.

  • Implementing linked data structures, such as linked lists, trees, and graphs.

  • Implementing functions that need to modify the value of a pointer passed as a parameter, for example, when inserting a node into a linked list.

  • Passing an array of pointers to a function for modification or processing.

  • Implementation of some sorting algorithms, where swapping elements requires the use of pointer to pointer.