C语言概述
C语言简介
开发环境搭建
Windows环境搭建
macOS环境搭建
Linux环境搭建
编写第一个程序 Hello World
编译与执行原理
基础语法
数据类型
变量与常量
运算符与表达式
标准输入输出
流程控制
条件判断
循环结构
控制流跳转
函数
函数的定义与调用
函数参数与返回值
变量作用域与生命周期
递归函数
数组与字符串
一维数组
多维数组
字符数组与字符串
常用字符串处理函数
指针
指针的概念与定义
指针运算
指针与数组
指针与函数
多级指针
内存管理
内存分区模型
动态内存分配
内存泄漏与防范
构造类型
结构体
共用体
枚举类型
typedef 的使用
文件操作
文件的打开与关闭
文件的顺序读写
文件的随机读写
进阶与工程化
预处理器
多文件编程
常见错误排查与调试
  1. c语言
  2. 指针
  3. 多级指针

多级指针

深入理解多级指针

多级指针是C语言中较为复杂的概念,但理解其本质后会发现其实很简单。东巴文（db-w.cn） 将带你深入理解多级指针的概念与应用。

💡 东巴文观点：多级指针本质上就是指针的指针,理解指针的本质是掌握多级指针的关键。

指针的本质回顾

指针存储地址

#include <stdio.h>

int main() {
    printf("=== 东巴文指针的本质 ===\n\n");
    
    int num = 10;
    int *ptr = &num;
    
    printf("num = %d\n", num);
    printf("&num = %p\n", &num);
    printf("ptr = %p\n", ptr);
    printf("*ptr = %d\n", *ptr);
    
    return 0;
}

东巴文说明：

  • 指针变量存储的是地址
  • & 取地址运算符
  • * 解引用运算符

二级指针

概念解析

#include <stdio.h>

int main() {
    printf("=== 东巴文二级指针概念 ===\n\n");
    
    int num = 10;
    int *ptr = &num;      // 一级指针
    int **pptr = &ptr;    // 二级指针
    
    printf("num = %d\n", num);
    printf("&num = %p\n\n", &num);
    
    printf("ptr = %p\n", ptr);
    printf("&ptr = %p\n", &ptr);
    printf("*ptr = %d\n\n", *ptr);
    
    printf("pptr = %p\n", pptr);
    printf("*pptr = %p\n", *pptr);
    printf("**pptr = %d\n", **pptr);
    
    return 0;
}

东巴文说明：

  • 二级指针是指针的指针
  • int **pptr - pptr是指向int指针的指针
  • *pptr 得到一级指针
  • **pptr 得到最终的数据

内存布局

#include <stdio.h>

int main() {
    printf("=== 东巴文二级指针内存布局 ===\n\n");
    
    int num = 100;
    int *ptr = &num;
    int **pptr = &ptr;
    
    printf("内存地址布局：\n");
    printf("num的地址：%p\n", &num);
    printf("num的值：%d\n\n", num);
    
    printf("ptr的地址：%p\n", &ptr);
    printf("ptr的值（指向num）：%p\n", ptr);
    printf("ptr指向的值：%d\n\n", *ptr);
    
    printf("pptr的地址：%p\n", &pptr);
    printf("pptr的值（指向ptr）：%p\n", pptr);
    printf("pptr指向的指针：%p\n", *pptr);
    printf("pptr最终指向的值：%d\n", **pptr);
    
    return 0;
}

通过二级指针修改值

#include <stdio.h>

void modifyValue(int **pptr, int newValue) {
    **pptr = newValue;
}

int main() {
    printf("=== 东巴文通过二级指针修改值 ===\n\n");
    
    int num = 10;
    int *ptr = &num;
    
    printf("修改前：num = %d\n", num);
    
    modifyValue(&ptr, 100);
    
    printf("修改后：num = %d\n", num);
    
    return 0;
}

多级指针的应用

动态二维数组

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

int main() {
    printf("=== 东巴文动态二维数组 ===\n\n");
    
    int rows = 3;
    int cols = 4;
    
    // 分配指针数组
    int **matrix = (int **)malloc(rows * sizeof(int *));
    
    // 为每一行分配内存
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
    }
    
    // 初始化
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j + 1;
        }
    }
    
    // 输出
    printf("动态二维数组：\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%2d ", matrix[i][j]);
        }
        printf("\n");
    }
    
    // 释放内存
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return 0;
}

字符串数组

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

int main() {
    printf("=== 东巴文字符串数组 ===\n\n");
    
    int count = 3;
    
    // 分配指针数组
    char **strings = (char **)malloc(count * sizeof(char *));
    
    // 为每个字符串分配内存
    strings[0] = (char *)malloc(20);
    strings[1] = (char *)malloc(20);
    strings[2] = (char *)malloc(20);
    
    // 初始化
    strcpy(strings[0], "Hello");
    strcpy(strings[1], "东巴文");
    strcpy(strings[2], "db-w.cn");
    
    // 输出
    printf("字符串数组：\n");
    for (int i = 0; i < count; i++) {
        printf("strings[%d] = %s\n", i, strings[i]);
    }
    
    // 释放内存
    for (int i = 0; i < count; i++) {
        free(strings[i]);
    }
    free(strings);
    
    return 0;
}

函数参数传递指针

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

void allocateMemory(int **ptr, int size) {
    *ptr = (int *)malloc(size * sizeof(int));
}

int main() {
    printf("=== 东巴文函数参数传递指针 ===\n\n");
    
    int *arr = NULL;
    int size = 5;
    
    printf("分配前：arr = %p\n", arr);
    
    allocateMemory(&arr, size);
    
    printf("分配后：arr = %p\n", arr);
    
    // 初始化
    for (int i = 0; i < size; i++) {
        arr[i] = i + 1;
    }
    
    // 输出
    printf("数组内容：\n");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    // 释放内存
    free(arr);
    
    return 0;
}

三级指针

概念解析

#include <stdio.h>

int main() {
    printf("=== 东巴文三级指针概念 ===\n\n");
    
    int num = 10;
    int *ptr = &num;       // 一级指针
    int **pptr = &ptr;     // 二级指针
    int ***ppptr = &pptr;  // 三级指针
    
    printf("num = %d\n", num);
    printf("*ptr = %d\n", *ptr);
    printf("**pptr = %d\n", **pptr);
    printf("***ppptr = %d\n", ***ppptr);
    
    return 0;
}

东巴文说明：

  • 三级指针是指针的指针的指针
  • 每增加一级,就多一层间接访问
  • 实际应用中很少使用三级及以上指针

三级指针应用

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

void allocate2DArray(int ***arr, int rows, int cols) {
    *arr = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        (*arr)[i] = (int *)malloc(cols * sizeof(int));
    }
}

int main() {
    printf("=== 东巴文三级指针应用 ===\n\n");
    
    int **matrix = NULL;
    int rows = 3, cols = 4;
    
    allocate2DArray(&matrix, rows, cols);
    
    // 初始化
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j + 1;
        }
    }
    
    // 输出
    printf("动态二维数组：\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%2d ", matrix[i][j]);
        }
        printf("\n");
    }
    
    // 释放内存
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return 0;
}

多级指针的遍历

遍历字符串数组

#include <stdio.h>

int main() {
    printf("=== 东巴文遍历字符串数组 ===\n\n");
    
    char *strings[] = {"Hello", "World", "东巴文"};
    char **ptr = strings;
    
    int count = sizeof(strings) / sizeof(strings[0]);
    
    printf("使用二级指针遍历：\n");
    for (int i = 0; i < count; i++) {
        printf("*(ptr + %d) = %s\n", i, *(ptr + i));
    }
    
    return 0;
}

遍历二维数组

#include <stdio.h>

int main() {
    printf("=== 东巴文遍历二维数组 ===\n\n");
    
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    int *ptr[3] = {matrix[0], matrix[1], matrix[2]};
    int **pptr = ptr;
    
    printf("使用二级指针遍历：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", *(*(pptr + i) + j));
        }
        printf("\n");
    }
    
    return 0;
}

东巴文最佳实践

1. 避免过多层级

#include <stdio.h>

int main() {
    printf("=== 东巴文避免过多层级 ===\n\n");
    
    // ✅ 推荐：使用必要的层级
    int num = 10;
    int *ptr = &num;
    int **pptr = &ptr;
    
    printf("二级指针：%d\n", **pptr);
    
    // ❌ 不推荐：使用过多层级
    // int ***ppptr = &pptr;
    // int ****pppptr = &ppptr;
    
    printf("\n建议：实际应用中很少需要超过二级指针\n");
    
    return 0;
}

2. 清晰的命名

#include <stdio.h>

int main() {
    printf("=== 东巴文清晰的命名 ===\n\n");
    
    int value = 100;
    
    // ✅ 推荐：清晰的命名
    int *ptrToValue = &value;
    int **ptrToPtrToValue = &ptrToValue;
    
    printf("value = %d\n", value);
    printf("*ptrToValue = %d\n", *ptrToValue);
    printf("**ptrToPtrToValue = %d\n", **ptrToPtrToValue);
    
    return 0;
}

3. 使用typedef简化

#include <stdio.h>

// 使用typedef简化多级指针
typedef int *IntPtr;
typedef IntPtr *IntPtrPtr;

int main() {
    printf("=== 东巴文使用typedef简化 ===\n\n");
    
    int num = 100;
    IntPtr ptr = &num;
    IntPtrPtr pptr = &ptr;
    
    printf("num = %d\n", num);
    printf("*ptr = %d\n", *ptr);
    printf("**pptr = %d\n", **pptr);
    
    return 0;
}

4. 内存管理

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

int main() {
    printf("=== 东巴文内存管理 ===\n\n");
    
    int rows = 3;
    int cols = 4;
    
    // 分配
    int **matrix = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
    }
    
    // 使用...
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j;
        }
    }
    
    printf("动态二维数组已分配\n");
    
    // ✅ 正确：按相反顺序释放
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    printf("内存已正确释放\n");
    
    return 0;
}

东巴文验证清单

完成本章学习后,请确认：

  • 理解指针的本质
  • 理解二级指针的概念
  • 掌握二级指针的应用
  • 理解三级指针的概念
  • 掌握多级指针的遍历
  • 掌握最佳实践

下一步学习

掌握多级指针后,你可以继续学习：

如果遇到问题,欢迎访问 东巴文（db-w.cn） 获取帮助！

东巴文（db-w.cn） - 让编程学习更简单

🎯 东巴文多级指针提示：多级指针本质上就是指针的指针。在 db-w.cn,我们会通过大量实例帮你掌握多级指针！

上一章：指针与函数
下一章：内存管理