共计 1444 个字符，预计需要花费 4 分钟才能阅读完成。

1. 血泪教训：那些年我们踩过的指针坑

还记得刚工作时遇到的崩溃问题：在遍历链表时，函数内修改了指针指向，但调用后链表头却神秘消失。调试两小时后发现，我误将 void modify(Node* p) 写成了 void modify(Node*& p)——这个小小的& 让整个链表操作完全失控。

更危险的案例来自内存泄漏：

void loadResource(Resource* res) {res = new Resource(); // 实际应该用 *& 参数
}

int main() {
    Resource* r = nullptr;
    loadResource(r); // 内存泄漏！// 以为 r 指向了新资源，实际仍是 nullptr
}

2. 底层机制：从栈帧看本质差异

2.1 * p 参数传递（传值）

1. 调用时复制指针值到栈帧
2. 函数内操作的是副本地址
3. 示意图：

   [main 栈帧]
   | 0x1000 |  ← 原始指针
   
   [func 栈帧]
   | 0x1000 |  ← 副本指针（修改不影响原始）

2.2 *&p 参数传递（传引用）

1. 传递指针变量的引用
2. 函数内直接操作原指针
3. 示意图：

   [main 栈帧]
   | 0x1000 |  ← func 通过引用直接修改此地址
   
   [func 栈帧]
   | &pointer |  ← 原指针的引用

3. 三大场景代码对比

场景 1：修改外部指针指向

// 错误版本（无法修改外部指针）void changePtr(int* p) {p = new int(42); 
}

// 正确版本
void changePtr(int*& p) {
    delete p; // 安全操作
    p = new int(42);
}

场景 2：链表操作

// 在链表头部插入节点
void insertFront(Node*& head, int val) { // 必须用引用
    Node* newNode = new Node{val, head};
    head = newNode; // 修改原指针
}

场景 3：多级指针

void initMatrix(int***& mat) { // 三级指针引用
    *mat = new int**[10];
    // ... 初始化各维度
}

4. 汇编视角看差异

x86-64 下函数调用的关键片段对比：

; *p 传参方式
mov     rax, QWORD PTR [rbp-8] ; 取指针值
mov     rdi, rax               ; 值拷贝到 rdi
call    func

; *&p 传参方式
lea     rax, [rbp-8]          ; 取指针地址
mov     rdi, rax              ; 传递地址
call    func

5. 进阶实战指南

5.1 内存安全检测

Valgrind 检测示例：

valgrind --leak-check=full \
         --show-leak-kinds=all \
         ./your_program

ASAN 编译选项：

clang++ -fsanitize=address -g your_code.cpp

5.2 性能影响

测试数据（i9-13900K）：
| 参数类型 | 调用耗时(ns) |
|————|————-:|
| 普通指针 | 2.3 |
| 指针引用 | 2.1 |

5.3 现代 C ++ 替代方案

推荐使用智能指针：

void process(std::unique_ptr<int>& p) {p = std::make_unique<int>(42);
}

6. 思考与实践

1. 为什么下列代码会崩溃？如何修复？

   void badCopy(char* p) {p = new char[100];
       strcpy(p, "danger!");
   }

2. 当需要同时修改指针指向和指针指向的内容时，参数应该如何设计？给出三种不同方案并分析优劣。

指针是 C ++ 的利刃，理解 *p 和*&p的区别就像明白刀刃的正反——用对了事半功倍，用错了伤及自身。希望本文能帮你避开那些我亲自踩过的坑。