What does **p mean in c?

Question

I know that int *p is a pointer but what does int **p mean exactly? What type of value is that? When I say now p= something, how is that working? I am seeing this in the creation of two-dimensional arrays with pointers.

Answer 1

In short, int **p; is a pointer to a pointer to an int. So, for example:

  int i, j;      // Integers;
  int *p = &i;   // Pointer to i
  *p = 1;        // i is now 1
  int *q = &j;   // Pointer to j
  int **s = &p;  // Pointer to p
  **s = 2;       // i is now 2
  s = &q;        // s now points to q (pointing to j)
  **s = 16;      // j is now 16
  s = &p;        // s now points to p (pointing to i)
  **s = 3;       // i is now 3
  p = &j;        // p now points to j
  **s = 17;      // j is now 17

One use case for a pointer to pointer could be a function which needs to output a pointer to an int and return a success/failure status:

  #include <stdbool.h>

  bool getIntHandle(unsigned handleId, int **handle)
  {
     static int handles[] = {12, 23, 34, 45};

     bool success = (handleId < sizeof(handles)/sizeof(handles[0])); // Check that handleId is in range
     if(success)
     {
         *handle = &handles[handleId];
     }
     return success;
  }

  int main(void)
  {
      int *handle;
      bool success = getIntHandle(2, &handle); // Get a pointer to the integer at index 2
      printf("*handle = %d\n", *handle);
      return 0;
  }

Answer 2

p is a pointer to a pointer to an int. It's the type int **p and the variable p stores an address.

Here is an example of its use. p is an array of two integer pointers. The first of the pointers p[0] points to an array of 3 integers, and the 2nd to an array of 4 integers (combined this is known as ragged array):

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

int main() {
    int **p = malloc(2 * sizeof(int *));
    printf("p = %p\n", p);

    p[0] = malloc(3 * sizeof(int));
    printf("p[0] = %p\n", p[0]);
    p[0][0] = 0;
    p[0][1] = 1;
    p[0][2] = 2;

    p[1] = malloc(4 * sizeof(int));
    printf("p[1] = %p\n", p[1]);
    p[1][0] = 3;
    p[1][1] = 4;
    p[1][2] = 5;
    p[1][3] = 6;

    free(p[0]);
    free(p[1]);
    free(p);
    return 0;
}

The most common use, however, is with a regular 2d array that is passed to a function which degrades to a pointer to a pointer.