Tutorial :How do pointer to pointers work in C?

Question:

How do pointers to pointers work in C? When would you use them?

Solution:1

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.

Solution:2

How do pointers to pointers work in C?

First a pointer is a variable, like any other variable, but that holds the address of a variable.

A pointer to a pointer is a variable, like any other variable, but that holds the address of a variable. That variable just happens to be a pointer.

When would you use them?

You can use them when you need to return a pointer to some memory on the heap, but not using the return value.

Example:

``int getValueOf5(int *p)  {    *p = 5;    return 1;//success  }    int get1024HeapMemory(int **p)  {    *p = malloc(1024);    if(*p == 0)      return -1;//error    else       return 0;//success  }  ``

And you call it like this:

``int x;  getValueOf5(&x);//I want to fill the int varaible, so I pass it's address in  //At this point x holds 5    int *p;      get1024HeapMemory(&p);//I want to fill the int* variable, so I pass it's address in  //At this point p holds a memory address where 1024 bytes of memory is allocated on the heap  ``

There are other uses too, like the main() argument of every C program has a pointer to a pointer for argv, where each element holds an array of chars that are the command line options. You must be careful though when you use pointers of pointers to point to 2 dimensional arrays, it's better to use a pointer to a 2 dimensional array instead.

Why it's dangerous?

``void test()  {    double **a;    int i1 = sizeof(a[0]);//i1 == 4 == sizeof(double*)      double matrix[ROWS][COLUMNS];    int i2 = sizeof(matrix[0]);//i2 == 240 == COLUMNS * sizeof(double)  }  ``

Here is an example of a pointer to a 2 dimensional array done properly:

``int (*myPointerTo2DimArray)[ROWS][COLUMNS]  ``

You can't use a pointer to a 2 dimensional array though if you want to support a variable number of elements for the ROWS and COLUMNS. But when you know before hand you would use a 2 dimensional array.

Solution:3

I like this "real world" code example of pointer to pointer usage, in Git 2.0, commit 7b1004b:

Linus once said:

I actually wish more people understood the really core low-level kind of coding. Not big, complex stuff like the lockless name lookup, but simply good use of pointers-to-pointers etc.
For example, I've seen too many people who delete a singly-linked list entry by keeping track of the "prev" entry, and then to delete the entry, doing something like

``if (prev)    prev->next = entry->next;  else    list_head = entry->next;  ``

and whenever I see code like that, I just go "This person doesn't understand pointers". And it's sadly quite common.

People who understand pointers just use a "pointer to the entry pointer", and initialize that with the address of the list_head. And then as they traverse the list, they can remove the entry without using any conditionals, by just doing a

``*pp =  entry->next  ``

Applying that simplification lets us lose 7 lines from this function even while adding 2 lines of comment.

``-   struct combine_diff_path *p, *pprev, *ptmp;  +   struct combine_diff_path *p, **tail = &curr;  ``

Chris points out in the comments to the 2016 video "Linus Torvalds's Double Pointer Problem " by Philip Buuck.

kumar points out in the comments the blog post "Linus on Understanding Pointers", where Grisha Trubetskoy explains:

Imagine you have a linked list defined as:

``typedef struct list_entry {      int val;      struct list_entry *next;  } list_entry;  ``

You need to iterate over it from the beginning to end and remove a specific element whose value equals the value of to_remove.
The more obvious way to do this would be:

``list_entry *entry = head; /* assuming head exists and is the first entry of the list */  list_entry *prev = NULL;    while (entry) { /* line 4 */      if (entry->val == to_remove)     /* this is the one to remove ; line 5 */          if (prev)             prev->next = entry->next; /* remove the entry ; line 7 */          else              head = entry->next;      /* special case - first entry ; line 9 */        /* move on to the next entry */      prev = entry;      entry = entry->next;  }  ``

What we are doing above is:

• iterating over the list until entry is `NULL`, which means weâ€™ve reached the end of the list (line 4).
• When we come across an entry we want removed (line 5),
• we assign the value of current next pointer to the previous one,
• thus eliminating the current element (line 7).

There is a special case above - at the beginning of the iteration there is no previous entry (`prev` is `NULL`), and so to remove the first entry in the list you have to modify head itself (line 9).

What Linus was saying is that the above code could be simplified by making the previous element a pointer to a pointer rather than just a pointer.
The code then looks like this:

``list_entry **pp = &head; /* pointer to a pointer */  list_entry *entry = head;    while (entry) {      if (entry->val == to_remove)          *pp = entry->next;        pp = &entry->next;      entry = entry->next;  }  ``

The above code is very similar to the previous variant, but notice how we no longer need to watch for the special case of the first element of the list, since `pp` is not `NULL` at the beginning. Simple and clever.

Also, someone in that thread commented that the reason this is better is because `*pp = entry->next` is atomic. It is most certainly NOT atomic.
The above expression contains two dereference operators (`*` and `->`) and one assignment, and neither of those three things is atomic.
This is a common misconception, but alas pretty much nothing in C should ever be assumed to be atomic (including the `++` and `--` operators)!

Solution:4

When covering pointers on a programming course at university, we were given two hints as to how to begin learning about them. The first was to view Pointer Fun With Binky. The second was to think about the Haddocks' Eyes passage from Lewis Carroll's Through the Looking-Glass

â€œYou are sad,â€ the Knight said in an anxious tone: â€œLet me sing you a song to comfort you.â€

â€œIs it very long?â€ Alice asked, for she had heard a good deal of poetry that day.

â€œIt's long,â€ said the Knight, â€œbut it's very, very beautiful. Everybody that hears me sing it - either it brings the tears to their eyes, or else -â€

â€œOr else what?â€ said Alice, for the Knight had made a sudden pause.

â€œOr else it doesn't, you know. The name of the song is called â€˜Haddocks' Eyes.â€™â€

â€œOh, that's the name of the song, is it?" Alice said, trying to feel interested.

â€œNo, you don't understand,â€ the Knight said, looking a little vexed. â€œThat's what the name is called. The name really is â€˜The Aged Aged Man.â€™â€

â€œThen I ought to have said â€˜That's what the song is calledâ€™?â€ Alice corrected herself.

â€œNo, you oughtn't: that's quite another thing! The song is called â€˜Ways And Meansâ€™: but that's only what it's called, you know!â€

â€œWell, what is the song, then?â€ said Alice, who was by this time completely bewildered.

â€œI was coming to that,â€ the Knight said. â€œThe song really is â€˜A-sitting On A Gateâ€™: and the tune's my own invention.â€

Solution:5

You may want to read this : Pointers to Pointers

Hope this helps to clarify some basic doubts.

Solution:6

When a reference to a pointer is required. For example, when you wish to modify the value (address pointed to) of a pointer variable declared in a calling function's scope inside a called function.

If you pass a single pointer in as an argument, you will be modifying local copies of the pointer, not the original pointer in the calling scope. With a pointer to a pointer, you modify the latter.

Solution:7

A pointer to a pointer is also called a handle. One usage for it is often when an object can be moved in memory or removed. One is often responsible to lock and unlock the usage of the object so it will not be moved when accessing it.

It's often used in memory restricted environment, ie the Palm OS.

Solution:8

You have a variable that contains an address of something. That's a pointer.

Then you have another variable that contains the address of the first variable. That's a pointer to pointer.

Solution:9

it's a pointer to the pointer's address value. (that's terrible I know)

basically, it lets you pass a pointer to the value of the address of another pointer, so you can modify where another pointer is pointing from a sub function, like:

``void changeptr(int** pp)  {    *pp=&someval;  }  ``

Solution:10

Consider the below figure and program to understand this concept better.

As per the figure, ptr1 is a single pointer which is having address of variable num.

``ptr1 = &num;  ``

Similarly ptr2 is a pointer to pointer(double pointer) which is having the address of pointer ptr1.

``ptr2 = &ptr1;  ``

A pointer which points to another pointer is known as double pointer. In this example ptr2 is a double pointer.

Values from above diagram :

``Address of variable num has : 1000  Address of Pointer ptr1 is: 2000  Address of Pointer ptr2 is: 3000  ``

Example:

``#include <stdio.h>    int main ()  {     int  num = 10;     int  *ptr1;     int  **ptr2;       // Take the address of var      ptr1 = &num;       // Take the address of ptr1 using address of operator &     ptr2 = &ptr1;       // Print the value     printf("Value of num = %d\n", num );     printf("Value available at *ptr1 = %d\n", *ptr1 );     printf("Value available at **ptr2 = %d\n", **ptr2);  }  ``

Output:

``Value of num = 10  Value available at *ptr1 = 10  Value available at **ptr2 = 10  ``

Solution:11

A pointer to pointer is, well, a pointer to pointer.

A meaningfull example of someType** is a bidimensional array: you have one array, filled with pointers to other arrays, so when you write

dpointer[5][6]

you access at the array that contains pointers to other arrays in his 5th position, get the pointer (let fpointer his name) and then access the 6th element of the array referenced to that array (so, fpointer[6]).

Solution:12

How it works: It is a variable that can store another pointer.

When would you use them : Many uses one of them is if your function wants to construct an array and return it to the caller.

``//returns the array of roll nos {11, 12} through paramater  // return value is total number of  students  int fun( int **i )  {      int *j;      *i = (int*)malloc ( 2*sizeof(int) );      **i = 11;  // e.g., newly allocated memory 0x2000 store 11      j = *i;      j++;      *j = 12; ;  // e.g., newly allocated memory 0x2004 store 12        return 2;  }    int main()  {      int *i;      int n = fun( &i ); // hey I don't know how many students are in your class please send all of their roll numbers.      for ( int j=0; j<n; j++ )          printf( "roll no = %d \n", i[j] );        return 0;  }  ``

Solution:13

I've created a 5 minute video that explains how pointers work:

Solution:14

There so many of the useful explanations, but I didnt found just a short description, so..

Basically pointer is address of the variable. Short summary code:

``     int a, *p_a;//declaration of normal variable and int pointer variable       a = 56;     //simply assign value       p_a = &a;   //save address of "a" to pointer variable       *p_a = 15;  //override the value of the variable    //print 0xfoo and 15   //- first is address, 2nd is value stored at this address (that is called dereference)       printf("pointer p_a is having value %d and targeting at variable value %d", p_a, *p_a);   ``

Also useful info can be found in topic What means reference and dereference

And I am not so sure, when can be pointers useful, but in common it is necessary to use them when you are doing some manual/dynamic memory allocation- malloc, calloc, etc.

So I hope it will also helps for clarify the problematic :)

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »