很多人学指针，是被“星号的数量、括号的位置、方括号的优先级”三连击劝退的。本文不堆概念，而是搭一套能落地的心智模型 + 语法规则 + 高频用法 + 易错警示。看完后，你能读懂（乃至写出）大多数复杂的指针声明。

一、先立根：指针的“值”和“类型”

• 值：一个地址（内存中的编号）。
• 类型：描述“这个地址指向什么”。它决定三件事 1）*p 解引用后的结果类型； 2）p+1 前进的步长（int* 走 4 或 8 字节，依平台而定；double* 走 8 字节……）； 3）const、对齐、函数原型等语义约束。

记住：类型是行为契约。星号不是装饰，和变量名紧密绑定。

二、基本声明与一个经典坑

int *p;      // p 是“指向 int 的指针”
char* s;     // 等价于 char *s; 星号与变量名绑定
int* a, b;   // a 是 int*，b 是 int（不是指针！）
int *x, *y;  // 两个都是指针，这是唯一安全的多声明写法

结论：一次声明多个变量时，每个指针变量前都写 *，别指望 int* a, b; 让 b 也变指针。

三、括号改变结合方式：数组指针、指针数组、函数指针

口诀：从变量名出发，按“右优先，再左，再入括号；遇到括号先处理括号”（Right-Left Rule 简化版）。

int *p[3];      // p 是“含 3 个元素的数组”，每个元素是 int*
int (*q)[3];    // q 是“指向含 3 个 int 的数组”的指针（数组指针）

int (*fp)(int); // fp 是“指向函数的指针”，该函数参数为 int，返回 int
int *f(int);    // f 是“函数，返回 int*”（不是函数指针）

• [] 与 () 的优先级高于 *。
• 想让 * 先与变量名结合，需要括号：(*q)。

四、多级指针：**、*** 是什么？

1）层级与内存示意

int x = 42;
int *p = &x;    // p 保存“x 的地址”
int **pp = &p;  // pp 保存“p 的地址”

内存视图（概念图）：

x:  [ 42 ] 
p:  [ &x ] -> 指向 x
pp: [ &p ] -> 指向 p -> 再指向 x

2）多级指针的三大刚需场景

场景 A：在函数里“修改外部指针”

#include <stdlib.h>

int create_buffer(size_t n, int **out) {
    *out = (int*)malloc(n * sizeof(int));
    return *out ? 0 : -1;
}

int main() {
    int *buf = NULL;
    if (create_buffer(100, &buf) == 0) {
        // 此时 buf 已在函数内被“间接赋值”
        free(buf);
    }
}

如果只传 int*，函数拿到的是拷贝，无法把新地址“带回去”。所以需要 int**。

场景 B：C 里常见的字符串数组/参数表

int main(int argc, char **argv) { /* ... */ }
// 等价于：char *argv[]

argv 是“指针数组”：每个元素是 char*，指向以 \0 结尾的字符串。

场景 C：二维数据的两种实现

• 数组的数组（连续内存）：int (*pa)[M] = malloc(N * sizeof(*pa)); 读写 pa[i][j]，缓存友好。
• 指针的数组（分散内存）：int **pp = malloc(N * sizeof(int*));，再为每行单独 malloc。 灵活，但内存不连续、释放更繁琐。

五、const 与多级指针：哪里“只读”？

把 const 看成“贴在它右侧紧邻的类型上”（const T 与 T const 等价）。

const int *p;        // “指向 const int 的指针”：*p 只读，p 可改指向
int * const p2 = ...;// “常量指针，指向 int”：p2 只读，*p2 可改
const int * const p3;// “指向 const int 的常量指针”：两者都只读

多级指针时，每一层都能独立加 const：

const int  x = 1;
const int *pc = &x;     // 指向只读 int
int const * const *ppc = &pc; // ppc 自身和 *ppc 都只读

警示：不要把 const T* 的地址赋给 T**。这会丢失只读性，编译器通常拒绝：

const int c = 1;
const int *pc = &c;
// int **pp = &pc; // 错误：可能通过 pp 修改 c

六、读声明的小训练（带答案）

试着先自己读，再看答案。

1. int *a[5]; 答：a 是含 5 个元素的数组，每个元素是 int*（指针数组）。
2. int (*b)[5]; 答：b 是“指向含 5 个 int 的数组”的指针（数组指针）。
3. int *(*c)[5]; 答：c 是“指向含 5 个元素的数组”的指针，数组元素类型是 int*（指向指针数组的指针）。
4. int (*d(int, double))[8]; 答：d 是函数，入参 (int, double)，返回“指向含 8 个 int 的数组”的指针。
5. int *(*fp)(void); 答：fp 是“指向函数的指针”，该函数无参，返回 int*。

七、实战片段：二维数据的两种声明与使用

连续内存（数组指针）——更像“真二维”

int N = 3, M = 4;
int (*mat)[M] = malloc(sizeof(int[N][M]));
for (int i = 0; i < N; ++i)
    for (int j = 0; j < M; ++j)
        mat[i][j] = i * 10 + j;

// 使用完毕
free(mat);

分散内存（指针的数组 + 多级指针）

int N = 3, M = 4;
int **rows = malloc(N * sizeof(int*));
for (int i = 0; i < N; ++i) {
    rows[i] = malloc(M * sizeof(int));
    for (int j = 0; j < M; ++j) rows[i][j] = i * 10 + j;
}

// 释放（顺序别反）
for (int i = 0; i < N; ++i) free(rows[i]);
free(rows);

选择建议：

• 需要与库接口兼容、行长度不一、常做“行级别增删”的场景：选择 int**。
• 注重性能（局部性）且行列固定：优先“数组指针 + 连续块”。

八、函数参数与“退化”

• 数组参数会退化为指针：void f(int a[]) 实际等价 void f(int *a)。
• 想在函数里修改“实参指针”的指向，就要传 T**： void init(T **out) { *out = ...; }。

九、常见陷阱清单（高频踩坑，逐个摘掉）

1. 未初始化的野指针：int *p; *p = 1; —— 未定义行为。务必初始化为 NULL 或有效地址。
2. 返回局部地址：int* f(){ int x; return &x; } —— 离开栈帧即悬垂。
3. 忘括号导致类型变化：int *p[3] 与 int (*p)[3] 天差地别。
4. void** 不是“万能适配器”：不同具体类型的二级指针不可随意混用，会破坏类型安全。
5. const 传播不当：避免把“指向只读”的地址赋给“指向可写的二级指针”。
6. 错用 sizeof：malloc(n * sizeof *p) 比 malloc(n * sizeof(int)) 更稳（跟随类型变更）。
7. 释放顺序错误：分配了多块就要按相反顺序逐块 free。
8. 以为“星多更快”：多级指针是语义需要，不是性能优化手段。

十、把复杂声明“拆皮”

当你面对怪兽级声明时，采用三步走：

1. 锁定名（变量名/函数名）。
2. 就近优先处理 [] 和 ()，用括号强制结合。
3. 沿类型向外扩，读出“指向…的指针”、“返回…的函数”等短语，直到还原完整语义。

配合这个流程，任何“int *(*x[3])(double)”之类的声明，也能读顺：

• x[3]：x 是 3 个元素的数组；
• (*x[3])(double)：数组元素是“指向函数的指针”，函数参 double；
• int *(*x[3])(double)：函数返回 int*。

十一、微练习（附简答）

1）写出“指向函数的指针，该函数参数为 const char*，返回 size_t”： 参考：size_t (*pf)(const char*);

2）写出“数组指针，指向含 16 个 double 的数组”： 参考：double (*pa)[16];

3）写出“指向只读 int 的常量二级指针”： 参考：int const * const *pp;

4）实现 bool try_alloc(int n, int **out)，成功返回 true，失败保持 *out==NULL： 参考

#include <stdbool.h>
#include <stdlib.h>

bool try_alloc(int n, int **out) {
    *out = NULL;
    int *p = malloc(n * sizeof *p);
    if (!p) return false;
    *out = p;
    return true;
}

收束

• 星号与变量名绑定，多变量声明时每个都写 *。
• 括号改变结合，用 Right-Left 思维读声明。
• 多级指针是语义工具：改外部指针、表达二维/链式结构、对接接口。
• const 分层贴靠，警惕只读性丢失。
• 写代码时优先“可读的意图”：必要时用 typedef 给复杂声明取一个好名字，减少心智负担。

把这些规则装进你的肌肉记忆，指针声明就再也不可怕了。