Pointer to Pointer

[jeff_rowa]

Hi guyz,
could you please tell me what's the use of pointer to a pointer? specially in function parameters.
Regards,

[Ganon11]

A pointer to a pointer is sometimes used to make dynamically-allocated 2D arrays. For instance,

int **array;
array = new int*[10];
for (int i = 0; i < 10; i++) {
   array[i] = new int[10];
}

This code will make a 10x10 array of integers.

Functions that accept double pointers (what I call them - not an official term) can use them as 2d arrays in the above manner.

I'm not sure if there's any other widespread usage of double pointers...

[jeff_rowa]

A pointer to a pointer is sometimes used to make dynamically-allocated 2D arrays. For instance,

int **array;
array = new int*[10];
for (int i = 0; i < 10; i++) {
   array[i] = new int[10];
}

This code will make a 10x10 array of integers.

Functions that accept double pointers (what I call them - not an official term) can use them as 2d arrays in the above manner.

I'm not sure if there's any other widespread usage of double pointers...

tnx for the reply

[Banfa]

I'm not sure if there's any other widespread usage of double pointers...

Loads :D

You can use a pointer to pointer in a function call if you want to return a pointer via a parameter, i.e.

char *pp;

Function(&pp);


void Function(char **ppp)
{
    (*ppp) = malloc(20);

    strcpy(*ppp, "Hellow World");
}

You need a pointer to a pointer to pass back the value of a pointer (in the same way you need a pointer to an int to pass back the value of an int), if you just had a pointer then the value of pp would not be changed.

Pointers to pointers can be useful in linked list manipulation, sometimes it is handy to have a pointer to your next pointer.


Just allocating memory is a rather trivial and boring use of a pointer to pointer that doesn't really exploit it's full potential.

[DeMan]

Furthermore (and forgive me if i'm repeating what you saud Banfa) a double pointer allows the called function to worry about memory......

Consider two functions:

int myMethod(char *inString, int size);
int myOtherMethod(char **inString, int *size);

myMethod can manipulate the data starting at pointer inString, but has to assume that memory has been allocated (generally you would expect that this is why size has been passed also).

int myMethod(char *inString, int size)
{
  char* tempString = inString;
  for(int i=0; i<size; i++)
  {
    *tempString = 'A';
    tempString ++;
  }
  return SUCCESS;  //where SUCCESS is defined somehwer.....
}

myOtherMethod can allocate memory to a pointer of whatever size it wants and the pass the buffer back (and you'll often find that size is a pointer also as above, so that we can update that. The idea is that we can either default to a particular value if size is not pased in OR the caller passes the size of data he expects, and we return how much he gets (fairly simple check to see that data is reasonable)

int myOtherMethod(char **inString, int *size)
{
  char *tempBuffer = NULL;
  if(*size > 0)  //Notice value AT size
  {
    tempBuffer = (char *)malloc(*size);
  }
  else
  {
    tempBuffer = (char *)malloc(DEFAULT_SIZE);
    *size = DEFAULT_SIZE;
  }
  //Do whatever we need to do with data

  //point callers pointer to our buffer
  *inString = tempBuffer;
}

NOTICE: we say *inString = tempBuffer ("the value AT inString = tempBuffer", since tempBuffer is a ptr and inString is a ptr to a ptr we update the (ptr) value AT ptr, ptr )



}

[RedSon]

However, be warned that the procedure that DeMan is talking about goes against good coding practices. When you write a routine it should focus on changing one thing, and returning a value. Routines that side effect multiple arguments are harder to debug and more difficult to follow when troubleshooting . Routines that operate like this are usually indicative of a poor design.

[DeMan]

I'm not sure that's necessarily true,

As an example....
If you want to read from storage, there is little point being passed a buffer of some arbitrary length, when you don't know how long the data will be. If the methos is creating a buffer, it should also return the length of said buffer so that the caller knows how much data they're dealing with.

Some people would suggest using another method and calling that "size" to acheive this, so that you first ask how big the data will be, then allocate a buffer that size, and pass it on to the read function. This idea has merit because the person allocating the buffer will be the person freeing it, however, by returning buffer and length together, we guarantee not (necessarily) that we return the length of data that should have been read, but the length of the ACTUAL buffer we created....that is, the caller does not need to make assume that we used their buffer as they intended.

Of course alternatives such as creating a structure that stores the size and a pointer to the buffer may be a different solution.......

[RedSon]

...Of course alternatives such as creating a structure that stores the size and a pointer to the buffer may be a different solution.......

Yes this is an important point. It highlights the difference between programming in your language of choice and programming into you language of choice.