例如，如果您想随机访问不连续的数据。

p -> [p0, p1, p2, ...]  
p0 -> data1
p1 -> data2

——用C

T ** p = (T **) malloc(sizeof(T*) * n);
p[0] = (T*) malloc(sizeof(T));
p[1] = (T*) malloc(sizeof(T));

存储一个指针p，它指向一个指针数组。每个指针指向一段数据。

如果sizeof(T)很大，则可能无法分配sizeof(T) * n字节的连续块(即使用malloc)。

这里的大多数答案或多或少都与应用程序编程有关。下面是一个嵌入式系统编程的例子。例如，以下是NXP Kinetis KL13系列微控制器参考手册的摘录，此代码片段用于从固件中运行驻留在ROM中的引导加载程序:

＂ 为了获得入口点的地址，用户应用程序读取包含引导加载程序API树指针的单词，该指针位于引导加载程序向量表的0x1C偏移量处。向量表被放置在引导加载器地址范围的底部，ROM的地址范围是0x1C00_0000。因此，API树指针位于地址0x1C00_001C。

引导加载程序API树是一个包含指向其他结构的指针的结构，这些结构具有引导加载程序的函数和数据地址。引导加载程序入口点总是API树的第一个单词。 ＂

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);

比较变量的修改值和指针的修改值:

#include <stdio.h>
#include <stdlib.h>

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(&A);
  printf("modi. A = %d\n", A);

  /*************************/

  int *P = NULL;

  printf("orig. P = %p\n", P);
  changeP(&P);
  printf("modi. P = %p\n", P);

  free(P);

  return EXIT_SUCCESS;
}

这帮助我避免指针被调用函数修改时返回指针的值(用于单链表)。

古老的(坏的):

int *func(int *P)
{
  ...
  return P;
}

int main(void)
{
  int *pointer;
  pointer = func(pointer);
  ...
}    

新(更好的):

void func(int **pointer)
{
  ...
}

int main(void)
{
  int *pointer;
  func(&pointer);
  ...
}    

例如，你可能想要确保当你释放某个东西的内存时，你将指针设置为空。

void safeFree(void** memory) {
    if (*memory) {
        free(*memory);
        *memory = NULL;
    }
}

当你调用这个函数时，你会用指针的地址来调用它

void* myMemory = someCrazyFunctionThatAllocatesMemory();
safeFree(&myMemory);

现在myMemory被设置为NULL，任何重用它的尝试都将是非常明显的错误。

字符串是使用双指针的一个很好的例子。字符串本身是一个指针，所以任何时候你需要指向一个字符串，你就需要一个双指针。

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 :)).

当你处理在应用程序其他地方被更改的指针时，你应该使用双指针。在处理返回和寻址给您的硬件时，您可能还会发现双指针是必须的。