How do pointer-to-pointers work in C? (and when might you use them?)

by

Let’s assume an 8 bit computer with 8 bit addresses (and thus only 256 bytes of memory). This is part of that memory (the numbers at the top are the addresses):

  54   55   56   57   58   59   60   61   62   63   64   65   66   67   68   69
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
|    | 58 |    |    | 63 |    | 55 |    |    | h  | e  | l  | l  | o  | \0 |    |
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+

What you can see here, is that at address 63 the string “hello” starts. So in this case, if this is the only occurrence of “hello” in memory then,

const char *c = "hello";

… defines c to be a pointer to the (read-only) string “hello”, and thus contains the value 63. c must itself be stored somewhere: in the example above at location 58. Of course we can not only point to characters, but also to other pointers. E.g.:

const char **cp = &c;

Now cp points to c, that is, it contains the address of c (which is 58). We can go even further. Consider:

const char ***cpp = &cp;

Now cpp stores the address of cp. So it has value 55 (based on the example above), and you guessed it: it is itself stored at address 60.

As to why one uses pointers to pointers:

  • The name of an array usually yields the address of its first element. So if the array contains elements of type t, a reference to the array has type t *. Now consider an array of arrays of type t: naturally a reference to this 2D array will have type (t *)* = t **, and is hence a pointer to a pointer.
  • Even though an array of strings sounds one-dimensional, it is in fact two-dimensional, since strings are character arrays. Hence: char **.
  • A function f will need to accept an argument of type t ** if it is to alter a variable of type t *.
  • Many other reasons that are too numerous to list here.

More Related Contents:

  1. What is pointer to string in C?
  2. whats the difference between dynamic memory allocation and normal memory allocation?
  3. pointer to string concept in c [closed]
  4. Pointer manipulation inside function
  5. Changing address contained by pointer using function
  6. How does free know how much to free?
  7. “Pointer from integer/integer from pointer without a cast” issues
  8. What exactly is the array name in c?
  9. Does free(ptr) where ptr is NULL corrupt memory?
  10. How to pass a 2D array by pointer in C?
  11. Pointer to pointer of structs indexing out of bounds(?) when I try to index anything other than zero
  12. Should I use char** argv or char* argv[]?
  13. How to use pointer expressions to access elements of a two-dimensional array in C?
  14. Difference between char* and const char*?
  15. In C, what is the correct syntax for declaring pointers?
  16. C typedef of pointer to structure
  17. Pointers – Difference between Array and Pointer
  18. Are “malloc(sizeof(struct a *))” and “malloc(sizeof(struct a))” the same?
  19. C – SizeOf Pointers
  20. Swapping pointers in C (char, int)
  21. What is double star (eg. NSError **)?
  22. Where in memory are string literals ? stack / heap? [duplicate]
  23. How to include a dynamic array INSIDE a struct in C?
  24. How can I return a character array from a function in C?
  25. C difference between *[] and **
  26. Difference between *ptr[10] and (*ptr)[10]
  27. How are we able to access the pointer after deallocating the memory?
  28. Printing pointers in C
  29. lvalue required as increment operand
  30. C pointer notation compared to array notation: When passing to function

Leave a Comment