C++函数调用中指针参数*p与*&p的深度解析与实战避坑指南

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

真实 bug 案例

最近在代码审查时发现一个典型错误：同事想通过函数修改外部指针的指向，结果使用了错误的参数传递方式。原始代码如下：

void bad_modify(int* p) {p = new int(42); // 只修改了局部副本
}

int main() {
    int* ptr = nullptr;
    bad_modify(ptr);
    // ptr 仍然是 nullptr!
    if (ptr) { // 空指针解引用风险
        std::cout << *ptr << std::endl;
    }
    return 0;
}

另一个生产环境的崩溃案例：在多级指针操作时混淆了 p 和 &p，导致内存泄漏：

void risky_operation(Node** p) {
    // 应该使用 *&p 的场景误用了 *p
    *p = (*p)->next; // 可能丢失原始节点
}

底层机制解析

1. *p 参数传递机制
2. 函数获得指针的副本（值传递）
3. 修改 p 本身不影响调用方

4. 栈帧上创建新的指针变量

5. *&p 参数传递机制

6. 获得指针的引用（引用传递）
7. 修改 p 会直接影响调用方
8. 操作的是原始指针的内存地址

内存布局示意图：

 调用前栈帧：[main::ptr] -> nullptr

* p 参数传递：[func::p]  -> nullptr (副本)

*&p 参数传递：[func::p]  -> [main::ptr] (引用)

典型场景代码对比

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

// 错误方式（仅修改副本）void change_ptr(int* p) {p = new int(10);
}

// 正确方式
void change_ptr_properly(int*& p) {
    delete p; // 安全释放
    p = new int(20);
}

场景 2：链式数据结构操作

struct Node {
    int data;
    Node* next;
};

// 危险版本
void append_node(Node* head, Node* newNode) {// 可能丢失链表头}

// 安全版本
void append_node_safe(Node*& head, Node* newNode) {if (!head) {
        head = newNode;
        return;
    }
    // ... 正常追加操作
}

场景 3：多级指针传递

void init_2d_array(int*** arr) {*arr = new int*[10];
    // 需要 *& 语义来修改外层指针
}

// 更清晰的现代 C ++ 方式
using IntPtr = std::unique_ptr<int[]>;
void modern_init(IntPtr& arr) {arr.reset(new int[10]);
}

汇编视角分析

x86-64 汇编片段对比（GCC 编译）：

; *p 参数传递
mov     rax, QWORD PTR [rbp-8]  ; 获取指针值
mov     QWORD PTR [rbp-24], rax ; 创建副本

; *&p 参数传递
lea     rax, [rbp-8]           ; 直接获取地址
mov     QWORD PTR [rbp-24], rax ; 传递引用 

关键知识点

内存安全检测

Valgrind 检测示例：

valgrind --leak-check=full ./your_program

ASAN 编译选项：

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

性能影响

基准测试数据（100 万次调用）：

现代 C ++ 替代方案

1. std::unique_ptr 用于独占所有权
2. std::shared_ptr 用于共享所有权
3. 引用参数替代指针参数

void modern_approach(std::unique_ptr<int>& p) {p.reset(new int(42));
}

思考题

1. 在实现二叉树旋转操作时，应该使用 p 还是 &p 作为参数？为什么？
2. 当函数需要返回多个指针结果时，比较以下三种方式的优劣：
3. 使用 *& 参数
4. 返回 std::tuple
5. 使用输出参数结构体

总结建议

1. 优先使用引用参数替代指针参数
2. 必须使用指针时，明确参数传递意图：
3. 需要修改指针本身：用 *&p
4. 只操作指针指向的内容：用 *p
5. 现代 C ++ 项目中尽量使用智能指针
6. 所有指针操作前必须做 nullptr 检查
7. 复杂指针操作应添加详细注释

通过理解这些底层差异，可以避免 90% 的指针相关 bug。建议在代码审查时特别注意指针参数的传递方式，这是许多资深工程师都会疏忽的细节。