What real use does a double pointer have? [closed]

Answer 1

Multiple indirection is largely a holdover from C (which has neither reference nor container types). You shouldn't see multiple indirection that much in well-written C++, unless you're dealing with a legacy C library or something like that.

Having said that, multiple indirection falls out of some fairly common use cases.

In both C and C++, array expressions will "decay" from type "N-element array of T" to "pointer to T" under most circumstances¹. So, assume an array definition like

T *a[N]; // for any type T

When you pass a to a function, like so:

foo( a );

the expression a will be converted from "N-element array of T *" to "pointer to T *", or T **, so what the function actually receives is

void foo( T **a ) { ... }

A second place they pop up is when you want a function to modify a parameter of pointer type, something like

void foo( T **ptr )
{
  *ptr = new_value();
}

void bar( void )
{
  T *val;
  foo( &val );
}

Since C++ introduced references, you probably won't see that as often. You'll usually only see that when working with a C-based API.

You can also use multiple indirection to set up "jagged" arrays, but you can achieve the same thing with C++ containers for much less pain. But if you're feeling masochistic:

T **arr;

try
{
  arr = new T *[rows];
  for ( size_t i = 0; i < rows; i++ )
    arr[i] = new T [size_for_row(i)];
}
catch ( std::bad_alloc& e )
{
  ...
}

But most of the time in C++, the only time you should see multiple indirection is when an array of pointers "decays" to a pointer expression itself.

---

1. The exceptions to this rule occur when the expression is the operand of the sizeof or unary & operator, or is a string literal used to initialize another array in a declaration.