深入理解C/C++指针传递：何时以及如何改变外部指针

深入理解C/C++指针传递：何时以及如何改变外部指针标签：C++, 指针, 函数参数, 内存管理, 编程技巧

在C和C++编程中，指针是强大而灵活的工具，但也是初学者最容易困惑的概念之一。一个常见的问题是：“把指针传进函数，改变它会影响外面的变量吗？”

答案是：取决于你如何传递指针，以及你改变的是什么。

本文将通过具体场景和代码示例，深入剖析指针在函数调用中的行为，并探讨在哪些实际场景中需要改变指针本身，以及如何正确实现。

一、核心概念：值传递的本质

C/C++ 中，所有函数参数都是值传递。这意味着函数接收的是实参的一个副本。

当你传递一个指针时，你传递的是指针变量的值（即地址），而不是指针变量本身（除非使用引用）。

 void func(int* ptr) {
     ptr = NULL; // 修改的是副本
 }
 ​
 int main() {
     int a = 10;
     int* p = &a;
     func(p);
     // p 仍然指向 &a，没有变成 NULL
     printf("p = %p\n", (void*)p); // 输出非 NULL
     return 0;
 }

在这个例子中，func 改变了 ptr 的值，但由于 ptr 是 p 的副本，原始指针 p 没有被修改。

二、改变指针指向的内容：最常见用法

大多数情况下，我们传递指针是为了修改指针所指向的数据，而不是指针本身。

场景示例：交换两个整数

 void swap(int* a, int* b) {
     int temp = *a;
     *a = *b;
     *b = temp;
 }
 ​
 int main() {
     int x = 5, y = 10;
     printf("交换前: x=%d, y=%d\n", x, y);
     swap(&x, &y);
     printf("交换后: x=%d, y=%d\n", x, y);
     return 0;
 }

分析：

• 我们通过 *a 和 *b 解引用，修改了 x 和 y 的值。

• 指针变量 a 和 b 本身没有被修改，但这不重要，因为我们关心的是数据。

三、何时需要改变指针变量本身？

有时，我们需要让函数改变指针本身，让它指向新的内存地址。这在以下场景中非常常见：

场景1：动态内存分配

你想在函数内部为指针分配内存，并让外部的指针也指向这块新内存。

❌ 错误做法（只传一级指针）：

 void allocate_memory(int* ptr) {
     ptr = malloc(sizeof(int)); // ptr 是副本
     *ptr = 42;
 }
 ​
 int main() {
     int* p = NULL;
     allocate_memory(p);
     // p 仍然是 NULL！内存泄漏且无法访问
     if (p) {
         printf("值: %d\n", *p);
         free(p);
     }
     return 0;
 }

✅ 正确做法1：传二级指针

 void allocate_memory(int** ptr) {
     *ptr = malloc(sizeof(int));
     if (*ptr) {
         **ptr = 42;
     }
 }
 ​
 int main() {
     int* p = NULL;
     allocate_memory(&p); // 传递 p 的地址
     if (p) {
         printf("分配成功，值: %d\n", *p); // 输出 42
         free(p);
     }
     return 0;
 }

✅ 正确做法2：C++ 中传指针引用

 void allocate_memory(int*& ptr) {
     ptr = new int(42);
 }
 ​
 int main() {
     int* p = nullptr;
     allocate_memory(p);
     if (p) {
         std::cout << "分配成功，值: " << *p << std::endl; // 输出 42
         delete p;
     }
     return 0;
 }

场景2：链表插入/删除操作

在链表操作中，经常需要修改头指针或某个节点的指针。

 struct Node {
     int data;
     struct Node* next;
 };
 ​
 // 在链表头部插入新节点
 void insert_at_head(struct Node** head, int value) {
     struct Node* new_node = malloc(sizeof(struct Node));
     new_node->data = value;
     new_node->next = *head; // 新节点指向原头节点
     *head = new_node;       // 更新头指针
 }
 ​
 int main() {
     struct Node* head = NULL;
     insert_at_head(&head, 10);
     insert_at_head(&head, 20);
     // 链表: 20 -> 10 -> NULL
     return 0;
 }

如果使用 insert_at_head(struct Node* head, ...)，则无法真正修改 head 指针。

场景3：字符串处理与内存重分配

 void append_char(char** str, char c) {
     int len = *str ? strlen(*str) : 0;
     *str = realloc(*str, len + 2); // 重新分配内存
     if (*str) {
         (*str)[len] = c;
         (*str)[len + 1] = '\0';
     }
 }
 ​
 int main() {
     char* str = NULL;
     append_char(&str, 'H');
     append_char(&str, 'i');
     printf("字符串: %s\n", str); // 输出 "Hi"
     free(str);
     return 0;
 }

realloc 可能会移动内存块，因此必须通过二级指针更新原始指针。

四、三种改变外部指针的方法对比

返回指针的替代方案：

 int* allocate_and_init() {
     int* p = malloc(sizeof(int));
     if (p) *p = 42;
     return p;
 }
 ​
 int main() {
     int* p = allocate_and_init();
     if (p) {
         printf("值: %d\n", *p);
         free(p);
     }
     return 0;
 }

五、最佳实践与建议

1. 明确意图：先想清楚你是想修改数据，还是修改指针本身。

2. 优先使用引用（C++）：在C++中，如果需要修改指针，优先使用引用（T*&），更安全直观。

3. C语言中用二级指针：在C中，使用二级指针是标准做法。

4. 避免内存泄漏：确保分配的内存被正确释放。

5. 检查空指针：在解引用前始终检查指针是否为 NULL。

结语

理解指针传递的机制是掌握C/C++的关键一步。记住：

改变指针副本 ≠ 改变原始指针 改变指针指向的内容 ≠ 改变指针本身

当你需要在函数中为指针分配内存、修改链表头节点或进行复杂的内存管理时，就必须使用二级指针或指针引用来真正改变外部的指针变量。

掌握这些技巧，你将能写出更健壮、更灵活的系统级代码。

讨论：你在实际项目中遇到过哪些需要改变指针本身的场景？欢迎在评论区分享你的经验！