摘要：在C语言中，指针可以指向变量的地址。多级指针（Pointers to Pointers 或 Multilevel Pointers）则是指向另一个指针地址的指针。这种概念可以扩展到任意级别（二级指针、三级指针等），但在实际应用中，二级指针最为常见，三级或更高级
在C语言中，指针可以指向变量的地址。多级指针（Pointers to Pointers 或 Multilevel Pointers）则是指向另一个指针地址的指针。这种概念可以扩展到任意级别（二级指针、三级指针等），但在实际应用中，二级指针最为常见，三级或更高级别的指针使用较少，因为它们会显著增加代码的复杂性。
二级指针是一个指向一级指针（即普通指针）的指针。它存储的是一个一级指针变量的地址。
类型 **指针名;
例如： int **ptr_to_ptr;
ptr_to_ptr 是一个二级指针变量名。第一个 * 表示 ptr_to_ptr 是一个指针。第二个 * (即 int *) 表示 ptr_to_ptr 指向的类型是一个 int*（即指向 int 型变量的指针）。所以，ptr_to_ptr 是一个“指向 (指向 int 型变量的指针) 的指针”。
++ ++ +-------+| ptr_to_ptr |----->| ptr |----->| var |++ ++ +-------+(二级指针) (一级指针) (普通变量)存储 ptr 的地址 存储 var 的地址 存储实际值var：一个普通变量，例如 int var = 10;ptr：一个一级指针，指向 var，例如 int *ptr = &var;ptr_to_ptr：一个二级指针，指向 ptr，例如 int **ptr_to_ptr = &ptr; #include int main {int var = 100;int *ptr; // 一级指针int **ptr_to_ptr; // 二级指针ptr = &var; // ptr 指向 var (存储 var 的地址)ptr_to_ptr = &ptr; // ptr_to_ptr 指向 ptr (存储 ptr 的地址)printf("Value of var = %d\n", var);printf("Value of var using ptr = %d\n", *ptr);printf("Value of var using ptr_to_ptr = %d\n", **ptr_to_ptr);printf("\nAddress of var = %p\n", (void*)&var);printf("Address stored in ptr = %p\n", (void*)ptr);printf("Address stored in *ptr_to_ptr = %p\n", (void*)*ptr_to_ptr);printf("\nAddress of ptr = %p\n", (void*)&ptr);printf("Address stored in ptr_to_ptr = %p\n", (void*)ptr_to_ptr);// 修改 var 的值通过不同级别的指针*ptr = 200; // 通过一级指针修改printf("\nAfter *ptr = 200, var = %d\n", var);**ptr_to_ptr = 300; // 通过二级指针修改printf("After **ptr_to_ptr = 300, var = %d\n", var);return 0;}这是二级指针最经典和常见的用途。如果希望一个函数能够修改调用者作用域中的一个一级指针（使其指向不同的内存地址），就必须将这个一级指针的地址（即二级指针）传递给函数。
背景：C语言函数参数传递是值传递。如果直接传递一级指针给函数，函数内部得到的是该指针的一个副本。在函数内部修改这个副本指针，使其指向新的地址，不会影响到调用者原始的一级指针。
示例：函数分配内存并返回给调用者
#include #include // 错误的方式：函数无法修改调用者的 original_ptrvoid allocate_memory_wrong(int *p, int size) {p = (int*)malloc(size * sizeof(int)); // p 是 original_ptr 的副本if (p == NULL) return;for (int i = 0; i如果需要创建一个指针数组，并且这个指针数组本身也是动态分配的，或者数组中的每个指针也指向动态分配的内存，这时二级指针就非常有用。
场景1：动态分配一个字符串数组
#include #include #include int main {int num_strings = 3;char **string_array; // 二级指针，将指向一个 char* 数组// 1. 为指针数组本身分配内存 (分配 num_strings 个 char* 指针的空间)string_array = (char**)malloc(num_strings * sizeof(char*));if (string_array == NULL) return 1;// 2. 为每个字符串分配内存并复制内容char temp_buffer[50];for (int i = 0; i场景2：动态分配二维数组 (矩阵)
虽然C99引入了变长数组(VLA)，但在某些情况下或旧标准中，动态分配二维数组通常通过二级指针实现。
#include #include int main {int rows = 3, cols = 4;int **matrix; // 二级指针，用于模拟二维数组// 1. 为行指针数组分配内存 (分配 rows 个 int* 指针的空间)matrix = (int**)malloc(rows * sizeof(int*));if (matrix == NULL) return 1;// 2. 为每一行分配内存 (每行有 cols 个 int 的空间)for (int i = 0; i注意：这种方式分配的“二维数组”，其每一行在内存中不一定是连续的（尽管 matrix[i] 本身是连续的）。如果需要整个二维数组在内存中是连续的，有其他分配技巧（例如，一次性分配 rows * cols * sizeof(int) 的大块内存，然后手动设置行指针）。
在 main 函数中，argv (argument vector) 就是一个典型的二级指针（或者更准确地说是指向指针数组的指针）： int main(int argc, char *argv) 或 int main(int argc, char **argv)
argv 是一个指向 char* 的指针数组的第一个元素的指针。每个 argv[i] 是一个 char*，指向一个命令行参数字符串。argv[0] 通常是程序名。argv[argc] 保证是 NULL。 #include // 编译后运行: ./myprogram arg1 test "another arg"int main(int argc, char *argv) { // char **argv 也可以printf("Program name: %s\n", argv[0]);printf("Number of arguments (excluding program name): %d\n", argc - 1);for (int i = 1; i理论上，指针的级别可以无限增加，例如三级指针 int ***ptr3;。 ptr3 指向一个二级指针，该二级指针指向一个一级指针，该一级指针指向一个 int 变量。
int var = 10;int *p1 = &var;int **p2 = &p1;int ***p3 = &p2;// ***p3 == **p2 == *p1 == var应用场景： 三级或更高级别的指针在常规应用中非常罕见，因为它们会使代码难以理解和维护。一些可能的（但通常可以避免或用其他方式实现的）场景包括：
在函数中修改一个二级指针。非常复杂的数据结构，例如指向指针数组的指针数组（动态分配的三维数组）。示例：函数修改二级指针
#include #include // 函数，试图修改调用者传入的二级指针 ppvoid modify_double_pointer(int ***ppp, int *new_target) {// *ppp 是调用者传入的二级指针 pp// **ppp 是调用者传入的一级指针 *pp// ***ppp 是调用者传入的 int **pp// 假设我们想让调用者的二级指针 pp 指向一个新的指针，// 而这个新的指针指向 new_targetint *new_single_ptr = new_target; // 假设 new_target 是一个 int 变量的地址// 创建一个新的二级指针，让它指向 new_single_ptr// 这通常不是我们想要的，因为这个 new_double_ptr 是局部的// int **new_double_ptr = &new_single_ptr; // *ppp = new_double_ptr; // 这样会导致问题，因为 new_double_ptr 是栈上的// 更常见的可能是，我们有一个已经存在的二级指针，想让调用者的二级指针指向它// 或者，我们动态分配一个新的指针，让调用者的二级指针指向它// 例如，让调用者的二级指针指向一个新分配的、指向 new_target 的一级指针int *intermediate_ptr = (int*)malloc(sizeof(int*)); // 这不是通常的做法// 通常是修改二级指针指向的一级指针// 或者修改一级指针指向的数据// 实际中，如果需要修改二级指针本身，通常是这个二级指针是动态分配的，// 并且我们想重新分配它，或者让它指向另一个动态分配的二级指针结构。// 一个更现实的（但仍然复杂）的例子：// 假设我们有一个函数，它需要创建一个指针数组 (char **)，// 并且这个指针数组本身也需要通过参数返回给调用者。// 这时，调用者会传递一个 char***。// 简化场景：让调用者的二级指针指向一个新的一级指针，该一级指针指向 new_targetstatic int *global_ptr_for_demo; // 使用 static 只是为了示例，避免局部变量问题global_ptr_for_demo = new_target;static int **global_double_ptr_for_demo = &global_ptr_for_demo;*ppp = global_double_ptr_for_demo; // 修改调用者的二级指针}int main {int val1 = 10, val2 = 20;int *p1 = &val1;int **pp1 = &p1;printf("Before: **pp1 = %d (points to val1)\n", **pp1);modify_double_pointer(&pp1, &val2); // 传递 pp1 的地址 (三级指针)// 和一个新的目标 val2 的地址printf("After: **pp1 = %d (should point to val2)\n", **pp1);// 注意：这个例子为了演示三级指针修改二级指针，使用了全局静态变量，// 这在实际代码中通常是不好的实践。更常见的是动态分配。return 0;}这个三级指针的例子比较牵强，因为直接修改二级指针指向的内容（即一级指针）通常用二级指针参数就够了。三级指针通常出现在需要动态管理二级指针本身（如动态创建和销毁一个二级指针数组）的场景。
复杂性：每增加一级指针，代码的理解难度和出错的可能性都会增加。尽量避免使用超过二级以上的指针，除非有非常充分的理由。类型匹配：确保指针的类型正确匹配。int* 和 int** 是完全不同的类型。解引用次数：小心计算需要多少次解引用 (*)才能访问到最终的数据。NULL 检查：在使用多级指针的每一级解引用之前，都应该检查指针是否为 NULL，以避免段错误。 if (ptr_to_ptr != NULL && *ptr_to_ptr != NULL) {// 安全地使用 **ptr_to_ptr}内存管理：如果多级指针涉及到动态分配的内存（例如，动态分配的指针数组，其中每个指针又指向动态分配的数据），释放内存时必须小心，通常需要从最内层开始逐层释放，最后释放最外层的指针数组本身。虽然多级指针提供了强大的功能，但也应该在必要时才使用，并力求代码清晰易懂。
来源：河北少儿教育
