Why use double indirection or Why use pointers to pointers

Question

When should a double indirection be used in C  Can anyone explain with a example   What I know is that a double indirection is a pointer to a pointer   Why would I need a pointer to a pointer

User · Answer

One thing I use them for constantly is when I have an array of objects and I need to perform lookups (binary search) on them by different fields.
I keep the original array...

int num_objects;
OBJECT *original_array = malloc(sizeof(OBJECT)*num_objects);

Then make an array of sorted pointers to the objects.

int compare_object_by_name( const void *v1, const void *v2 ) {
  OBJECT *o1 = *(OBJECT **)v1;
  OBJECT *o2 = *(OBJECT **)v2;
  return (strcmp(o1->name, o2->name);
}

OBJECT **object_ptrs_by_name = malloc(sizeof(OBJECT *)*num_objects);
  int i = 0;
  for( ; i<num_objects; i++)
    object_ptrs_by_name[i] = original_array+i;
  qsort(object_ptrs_by_name, num_objects, sizeof(OBJECT *), compare_object_by_name);

You can make as many sorted pointer arrays as you need, then use a binary search on the sorted pointer array to access the object you need by the data you have. The original array of objects can stay unsorted, but each pointer array will be sorted by their specified field.

User · Answer

Compare modifying value of variable versus modifying value of pointer    include  lt stdio h gt   include  lt stdlib h gt   void changeA int   a         a    10     void changeP int    P         P    malloc sizeof   P        int main void      int A   0     printf  orig  A    d n   A     changeA  amp A     printf  modi  A    d n   A                                     int  P   NULL     printf  orig  P    p n   P     changeP  amp P     printf  modi  P    p n   P      free P      return EXIT SUCCESS      This helped me to avoid returning value of pointer when the pointer was modified by the called function  used in singly linked list    OLD  bad    int  func int  P            return P     int main void      int  pointer    pointer   func pointer                 NEW  better    void func int   pointer             int main void      int  pointer    func  amp pointer

User · Answer

The following is a very simple C   example that shows that if you want to use a function to set a pointer to point to an object  you need a pointer to a pointer  Otherwise  the pointer will keep reverting to null    A C   answer  but I believe it s the same in C     Also  for reference  Google  pass by value c        By default  arguments in C   are passed by value  When an argument is passed by value  the argument s value is copied into the function s parameter     So we want to set the pointer b equal to the string a    include  lt iostream gt   include  lt string gt   void Function 1 std  string  a  std  string  b      b   a    std  cout  lt  lt   b    nullptr       False    void Function 2 std  string  a  std  string   b       b   a    std  cout  lt  lt   b    nullptr       False    int main       std  string a  Hello       std  string  b nullptr     std  cout  lt  lt   b    nullptr       True    Function 1  amp a  b     std  cout  lt  lt   b    nullptr       True    Function 2  amp a   amp b     std  cout  lt  lt   b    nullptr       False       Output  10100   What happens at the line Function 1  amp a  b      The  value  of  amp main  a  an address  is copied into the parameter std  string  Function 1  a  Therefore Function 1  a is a pointer to  i e  the memory address of  the string main  a  The  value  of main  b  an address in memory  is copied into the parameter std  string  Function 1  b  Therefore there are now 2 of these addresses in memory  both null pointers  At the line b   a   the local variable Function 1  b is then changed to equal Function 1  a     amp main  a   but the variable main  b is unchanged  After the call to Function 1  main  b is still a null pointer    What happens at the line Function 2  amp a   amp b      The treatment of the a variable is the same  within the function  Function 2  a is the address of the string main  a  But the variable b is now being passed as a pointer to a pointer  The  value  of  amp main  b  the address of the pointer main  b  is copied into std  string   Function 2  b  Therefore within Function 2  dereferencing this as  Function 2  b will access and modify main  b   So the line  b   a  is actually setting main  b  an address  equal to Function 2  a    address of main  a  which is what we want    If you want to use a function to modify a thing  be it an object or an address  pointer   you have to pass in a pointer to that thing  The thing that you actually pass in cannot be modified  in the calling scope  because a local copy is made    An exception is if the parameter is a reference  such as std  string amp  a  But usually these are const  Generally  if you call f x   if x is an object you should be able to assume that f won t modify x  But if x is a pointer  then you should assume that f might modify the object pointed to by x

User · Answer

For instance if you want random access to noncontiguous data   p - gt   p0  p1  p2         p0 - gt  data1 p1 - gt  data2   -- in C  T    p    T     malloc sizeof T     n   p 0     T   malloc sizeof T    p 1     T   malloc sizeof T      You store a pointer p that points to an array of pointers  Each pointer points to a piece of data   If sizeof T  is big it may not be possible to allocate a contiguous block  ie using malloc  of sizeof T    n bytes

User · Answer

Pointers to pointers also come in handy as  handles  to memory where you want to pass around a  handle  between functions to re-locatable memory   That basically means that the function can change the memory that is being pointed to by the pointer inside the handle variable  and every function or object that is using the handle will properly point to the newly relocated  or allocated  memory   Libraries like to-do this with  opaque  data-types  that is data-types were you don t have to worry about what they re doing with the memory being pointed do  you simply pass around the  handle  between the functions of the library to perform some operations on that memory     the library functions can be allocating and de-allocating the memory under-the-hood without you having to explicitly worry about the process of memory management or where the handle is pointing   For instance    include  lt stdlib h gt   typedef unsigned char   handle type     some data structure that the library functions would work with typedef struct        int data a      int data b      int data c    LIB OBJECT   handle type lib create handle           initialize the handle with some memory that points to and array of 10 LIB OBJECTs     handle type handle   malloc sizeof handle type         handle   malloc sizeof LIB OBJECT    10        return handle     void lib func a handle type handle      does something with array of LIB OBJECTs      void lib func b handle type handle          does something that takes input LIB OBJECTs and makes more of them  so has to       reallocate memory for the new objects that will be created        first re-allocate the memory somewhere else with more slots  but don t destroy the       currently allocated slots      handle   realloc  handle  sizeof LIB OBJECT    20             do some operation on the new memory and return    void lib func c handle type handle      does something else to array of LIB OBJECTs      void lib free handle handle type handle         free  handle       free handle        int main           create a  handle  to some memory that the library functions can use     handle type my handle   lib create handle           do something with that memory     lib func a my handle          do something else with the handle that will make it point somewhere else       but that s invisible to us from the standpoint of the calling the function and       working with the handle     lib func b my handle           do something with new memory chunk  but you don t have to think about the fact       that the memory has moved under the hood     it s still pointed to by the  handle      lib func c my handle          deallocate the handle     lib free handle my handle        return 0      Hope this helps   Jason

User · Answer

Most of the answers here are more or less related to application programming  Here is an example from embedded systems programming  For example below is an excerpt from the reference manual of NXP s Kinetis KL13 series microcontroller  this code snippet is used to run bootloader  which resides in ROM  from firmware   quot  To get the address of the entry point  the user application reads the word containing the pointer to the bootloader API tree at offset 0x1C of the bootloader s vector table  The vector table is placed at the base of the bootloader s address range  which for the ROM is 0x1C00 0000  Thus  the API tree pointer is at address 0x1C00 001C  The bootloader API tree is a structure that contains pointers to other structures  which have the function and data addresses for the bootloader  The bootloader entry point is always the first word of the API tree   quot  uint32 t runBootloaderAddress  void   runBootloader  void   arg      Read the function address from the ROM API tree  runBootloaderAddress      uint32 t     0x1c00001c   runBootloader    void     void   arg  runBootloaderAddress     Start the bootloader  runBootloader NULL

User · Answer

1  Basic Concept -  When you declare as follows   -  1  char  ch -     called character pointer  - ch contains the address of a single character  -   ch  will dereference to the value of the character      2  char   ch -  ch  contains the address of an Array of character pointers   as in 1    ch  contains the address of a single character   Note that it s different from 1  due to difference in declaration      ch  will dereference to the exact value of the character    Adding more pointers expand the dimension of a datatype  from character to string  to array of strings  and so on    You can relate it to a 1d  2d  3d matrix    So  the usage of pointer depends upon how you declare it   Here is a simple code    int main         char   p      p    char    malloc 100       p 0     char    Apple           or write  p  points to location of  A      p 1     char    Banana          or write   p 1   points to location of  B       cout  lt  lt   p  lt  lt  endl             Prints the first pointer location until it finds   0      cout  lt  lt    p  lt  lt  endl            Prints the exact character which is being pointed      p                             Increments for the next string     cout  lt  lt   p      2  Another Application of Double Pointers -  this would also cover pass by reference   Suppose you want to update a character from a function  If you try the following   -  void func char ch        ch    B      int main         char ptr      ptr    A       printf   c   ptr        func ptr       printf   c n   ptr       The output will be AA  This doesn t work  as you have  Passed By Value  to the function   The correct way to do that would be -  void func  char  ptr           Passed by Reference        ptr    B      int main         char  ptr      ptr    char   malloc sizeof char    1        ptr    A       printf   c n    ptr        func ptr       printf   c n    ptr       Now extend this requirement for updating a string instead of character  For this  you need to receive the parameter in the function as a double pointer   void func char   str        strcpy str   Second       int main         char   str         printf   d n   sizeof char         str    char    malloc sizeof char    10              Can hold 10 character pointers     int i   0      for i 0 i lt 10 i                  str    char   malloc sizeof char    1             Each pointer can point to a memory of 1 character             strcpy str   First        printf   s n   str       func str       printf   s n   str       In this example  method expects a double pointer as a parameter to update the value of a string

User · Answer

For example  you might want to make sure that when you free the memory of something you set the pointer to null afterwards   void safeFree void   memory        if   memory            free  memory            memory   NULL            When you call this function you d call it with the address of a pointer  void  myMemory   someCrazyFunctionThatAllocatesMemory    safeFree  amp myMemory     Now myMemory is set to NULL and any attempt to reuse it will be very obviously wrong

User · Answer

One reason is you want to change the value of the pointer passed to a function as the function argument  to do this you require pointer to a pointer  In simple words  Use    when you want to preserve  OR retain change in  the Memory-Allocation or Assignment even outside of a function call   So  Pass such function with double pointer arg   This may not be a very good example  but will show you the basic use   include  lt stdio h gt   include  lt stdlib h gt   void allocate int   p         p    int   malloc sizeof int       int main         int  p   NULL      allocate  amp p        p   42      printf  quot  d n quot    p       free p

User · Answer

I saw a very good example today  from this blog post  as I summarize below   Imagine you have a structure for nodes in a linked list  which probably is  typedef struct node       struct node   next             node    Now you want to implement a remove if function  which accepts a removal criterion rm as one of the arguments and traverses the linked list  if an entry satisfies the criterion  something like rm entry   true   its node will be removed from the list  In the end  remove if returns the head  which may be different from the original head  of the linked list   You may write  for  node   prev   NULL    curr   head  curr    NULL          node   const next   curr- gt next      if  rm curr                 if  prev      the node to be removed is not the head             prev- gt next   next          else          remove the head             head   next          free curr             else         prev   curr      curr   next      as your for loop  The message is  without double pointers  you have to maintain a prev variable to re-organize the pointers  and handle the two different cases   But with double pointers  you can actually write     now head is a double pointer for  node   curr   head   curr          node   entry    curr      if  rm entry                  curr   entry- gt next          free entry             else         curr    amp entry- gt next      You don t need a prev now because you can directly modify what prev- gt next pointed to   To make things clearer  let s follow the code a little bit  During the removal    if entry     head  it will be  head     curr     head- gt next -- head now points to the pointer of the new heading node  You do this by directly changing head s content to a new pointer  if entry     head  similarly   curr is what prev- gt next pointed to  and now points to entry- gt next    No matter in which case  you can re-organize the pointers in a unified way with double pointers

User · Answer

Let   s say you have a pointer  Its value is an address  but now you want to change that address  you could  by doing pointer1   pointer2  you give pointer1 the address of pointer2  but  if you do that within a function  and you want the result to persist after the function is done  you need do some extra work  you need a new pointer3 just to point to pointer1  pass pointer3 to the function  here is an example  look at the output below first  to understand       include  lt stdio h gt   int main          int c   1      int d   2      int e   3      int   a    amp c      int   b    amp d      int   f    amp e      int    pp    amp a      pointer to pointer  a       printf   n a s value   x  n   a       printf   n b s value   x  n   b       printf   n f s value   x  n   f       printf   n can we change a   lets see  n        printf   n a   b  n        a   b      printf   n a s value is now   x  same as  b     it seems we can  but can we do it in a function  lets see     n   a       printf   n cant change a  f    n        cant change a  f       printf   n a s value is now   x  Doh  same as  b      that function tricked us   n   a        printf   n NOW  lets see if a pointer to a pointer solution can help us    remember that  pp  point to  a   n         printf   n change pp  f    n        change pp  f       printf   n a s value is now   x  YEAH  same as  f      that function ROCKS      n   a       return 0     void cant change int   x  int   z       x   z      printf   n ---- gt  value of  a  is   x inside function  same as  f   BUT will it be the same outside of this function  lets see n   x      void change int    x  int   z        x   z      printf   n ---- gt  value of  a  is   x inside function  same as  f   BUT will it be the same outside of this function  lets see n    x       Here is the output   read this first      a s value  bf94c204   b s value  bf94c208    f s value  bf94c20c    can we change a   lets see    a   b    a s value is now  bf94c208  same as  b     it seems we can  but can we do it in a function  lets see       cant change a  f      ---- gt  value of  a  is  bf94c20c inside function  same as  f   BUT will it be the same outside of this function  lets see   a s value is now  bf94c208  Doh  same as  b      that function tricked us     NOW  lets see if a pointer to a pointer solution can help us    remember that  pp  point to  a     change pp  f      ---- gt  value of  a  is  bf94c20c inside function  same as  f   BUT will it be the same outside of this function  lets see   a s value is now  bf94c20c  YEAH  same as  f      that function ROCKS

User · Answer

I have used double pointers today while I was programming something for work  so I can answer why we had to use them  it s the first time I actually had to use double pointers   We had to deal with real time encoding of frames contained in buffers which are members of some structures  In the encoder we had to use a pointer to one of those structures  The problem was that our pointer was being changed to point to other structures from another thread  In order to use the current structure in the encoder  I had to use a double pointer  in order to point to the pointer that was being modified in another thread  It wasn t obvious at first  at least for us  that we had to take this approach  A lot of address were printed in the process       You SHOULD use double pointers when you work on pointers that are changed in other places of your application  You might also find double pointers to be a must when you deal with hardware that returns and address to you

User · Answer

If you want to have a list of characters  a word   you can use char  word  If you want a list of words  a sentence   you can use char   sentence  If you want a list of sentences  a monologue   you can use char    monologue  If you want a list of monologues  a biography   you can use char     biography  If you want a list of biographies  a bio-library   you can use char      biolibrary  If you want a list of bio-libraries  a   lol   you can use char       lol           yes  I know these might not be the best data structures    Usage example with a very very very boring lol   include  lt stdio h gt   include  lt stdlib h gt   include  lt string h gt   int wordsinsentence char   x        int w   0      while   x            w    1          x              return w     int wordsinmono char    x        int w   0      while   x            w    wordsinsentence  x           x              return w     int wordsinbio char     x        int w   0      while   x            w    wordsinmono  x           x              return w     int wordsinlib char      x        int w   0      while   x            w    wordsinbio  x           x              return w     int wordsinlol char       x        int w   0      while   x            w    wordsinlib  x           x              return w     int main void        char  word      char   sentence      char    monologue      char     biography      char      biolibrary      char       lol         fill data structure     word   malloc 4   sizeof  word      assume it worked     strcpy word   foo         sentence   malloc 4   sizeof  sentence      assume it worked     sentence 0    word      sentence 1    word      sentence 2    word      sentence 3    NULL       monologue   malloc 4   sizeof  monologue      assume it worked     monologue 0    sentence      monologue 1    sentence      monologue 2    sentence      monologue 3    NULL       biography   malloc 4   sizeof  biography      assume it worked     biography 0    monologue      biography 1    monologue      biography 2    monologue      biography 3    NULL       biolibrary   malloc 4   sizeof  biolibrary      assume it worked     biolibrary 0    biography      biolibrary 1    biography      biolibrary 2    biography      biolibrary 3    NULL       lol   malloc 4   sizeof  lol      assume it worked     lol 0    biolibrary      lol 1    biolibrary      lol 2    biolibrary      lol 3    NULL       printf  total words in my lol   d n   wordsinlol lol         free lol       free biolibrary       free biography       free monologue       free sentence       free word       Output   total words in my lol  243

User · Answer

A little late to the party  but hopefully this will help someone  In C arrays always allocate memory on the stack  thus a function can t return a  non-static  array due to the fact that memory allocated on the stack gets freed automatically when the execution reaches the end of the current block  That s really annoying when you want to deal with two-dimensional arrays  i e  matrices  and implement a few functions that can alter and return matrices  To achieve this  you could use a pointer-to-pointer to implement a matrix with dynamically allocated memory     Initializes a matrix    double   init matrix int num rows  int num cols          Allocate memory for num rows float-pointers     double   A   calloc num rows  sizeof double            return NULL if the memory couldn t allocated     if A    NULL  return NULL         For each double-pointer  row  allocate memory for num cols floats     for int i   0  i  lt  num rows  i             A i    calloc num cols  sizeof double               return NULL if the memory couldn t allocated            and free the already allocated memory         if A i     NULL               for int j   0  j  lt  i  j                     free A j                              free A               return NULL                      return A      Here s an illustration  double         double            double              -------------       ---------------------------------------------------------    A ------ gt      A 0       ---- gt    A 0  0    A 0  1    A 0  2               A 0  cols-1                   ---------         ---------------------------------------------------------                  A 1       ---- gt    A 1  0    A 1  1    A 1  2               A 1  cols-1                   ---------         ---------------------------------------------------------                                                                                                                                                                                                                ---------         ---------------------------------------------------------                  A i       ---- gt    A i  0    A i  1    A i  2               A i  cols-1                   ---------         ---------------------------------------------------------                                                                                                                                                                                                                ---------         ---------------------------------------------------------                A rows-1    ---- gt    A rows-1  0    A rows-1  1          A rows-1  cols-1                 -------------       ---------------------------------------------------------  The double-pointer-to-double-pointer A points to the first element A 0  of a memory block whose elements are double-pointers itself  You can imagine these double-pointers as the rows of the matrix  That s the reason why every double-pointer allocates memory for num cols elements of type double  Furthermore A i  points to the i-th row  i e  A i  points to A i  0  and that s just the first double-element of the memory block for the i-th row  Finally  you can access the element in the i-th row and j-th column easily with A i  j   Here s a complete example that demonstrates the usage   include  lt stdio h gt   include  lt stdlib h gt   include  lt time h gt      Initializes a matrix    double   init matrix int num rows  int num cols          Allocate memory for num rows double-pointers     double   matrix   calloc num rows  sizeof double            return NULL if the memory couldn t allocated     if matrix    NULL  return NULL         For each double-pointer  row  allocate memory for num cols        doubles     for int i   0  i  lt  num rows  i             matrix i    calloc num cols  sizeof double               return NULL if the memory couldn t allocated            and free the already allocated memory         if matrix i     NULL               for int j   0  j  lt  i  j                     free matrix j                              free matrix               return NULL                      return matrix        Fills the matrix with random double-numbers between -1 and 1    void randn fill matrix double   matrix  int rows  int cols       for  int i   0  i  lt  rows    i           for  int j   0  j  lt  cols    j               matrix i  j     double  rand   RAND MAX 2 0-1 0                         Frees the memory allocated by the matrix    void free matrix double   matrix  int rows  int cols       for int i   0  i  lt  rows  i             free matrix i              free matrix         Outputs the matrix to the console    void print matrix double   matrix  int rows  int cols       for int i   0  i  lt  rows  i             for int j   0  j  lt  cols  j                 printf  quot   - f  quot   matrix i  j                      printf  quot  n quot              int main        srand time NULL        int m   3  n   3      double   A   init matrix m  n       randn fill matrix A  m  n       print matrix A  m  n       free matrix A  m  n       return 0

User · Answer

Strings are a great example of uses of double pointers  The string itself is a pointer  so any time you need to point to a string  you ll need a double pointer

User · Answer

Simple example that you probably have seen many times before  int main int argc  char   argv    In the second parameter you have it  pointer to pointer to char   Note that the pointer notation  char  c  and the array notation  char c    are interchangeable in function arguments  So you could also write char  argv    In other words char  argv   and char   argv are interchangeable    What the above represents is in fact an array of character sequences  the command line arguments that are given to a program at startup    See also this answer for more details about the above function signature

User · Answer

Adding to Asha s response  if you use single pointer to the example bellow  e g  alloc1     you will lose the reference to the memory allocated inside the function   include  lt stdio h gt   include  lt stdlib h gt   void alloc2 int   p         p    int  malloc sizeof int          p   10     void alloc1 int  p        p    int  malloc sizeof int         p   10     int main        int  p   NULL      alloc1 p         printf  quot  d  quot   p    undefined     alloc2  amp p       printf  quot  d  quot   p    will print 10     free p       return 0     The reason it occurs like this is that in alloc1 the pointer is passed in by value  So  when it is reassigned to the result of the malloc call inside of alloc1  the change does not pertain to code in a different scope

User · Answer

Why double pointers   The objective is to change what studentA points to  using a function    include  lt stdio h gt   include  lt stdlib h gt    typedef struct Person      char   name    Person           we need a ponter to a pointer  example   amp studentA     void change Person    x  Person   y        x   y     since x is a pointer to a pointer  we access its value  a pointer to a Person struct     void dontChange Person   x  Person   y       x   y     int main          Person   studentA    Person   malloc sizeof Person        studentA- gt name    brian        Person   studentB    Person   malloc sizeof Person        studentB- gt name    erich                   we could have done the job as simple as this         but we need more work if we want to use a function to do the job                 studentA   studentB       printf  1  studentA    s  not changed  n   studentA- gt name        dontChange studentA  studentB       printf  2  studentA    s  not changed  n   studentA- gt name        change  amp studentA  studentB       printf  3  studentA    s  changed   n   studentA- gt name        return 0            OUTPUT     1  studentA   brian  not changed     2  studentA   brian  not changed     3  studentA   erich  changed

[c] Why use double indirection? or Why use pointers to pointers?

Examples related to c

Examples related to pointers