C 传递指针给函数（长文解析）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在 C 语言中，函数是程序的核心组成部分，而指针则是实现复杂功能的重要工具。将指针传递给函数，能够突破函数参数传递的局限性，实现数据的高效共享、动态内存操作以及复杂结构的交互。对于编程初学者而言，理解这一机制可能略显抽象，但对于中级开发者来说，掌握它则是迈向高级编程的关键一步。本文将从基础概念出发，通过实例和类比，逐步解析“C 传递指针给函数”的原理与应用。

一、理解指针与函数的基础概念

1.1 指针的本质：内存地址的“快递单”

指针是一个变量，它存储的是另一个变量的内存地址。可以将指针想象为快递单上的地址信息：当你想将包裹（数据）发送到某处时，只需提供地址，无需搬运整个包裹本身。类似地，指针通过存储变量的地址，让程序能够间接访问和修改该变量的值。

1.2 函数的参数传递机制：值传递的局限性

在 C 语言中，默认情况下，函数参数是按值传递的。这意味着：

• 传递的是变量的副本，函数内部对参数的修改不会影响原变量。
• 无法直接修改调用者的数据，例如无法在函数内部交换两个外部变量的值。

例如，以下代码尝试交换两个整数的值，但会失败：

void swap_by_value(int a, int b) {  
    int temp = a;  
    a = b;  
    b = temp;  
}  
int main() {  
    int x = 5, y = 10;  
    swap_by_value(x, y);  
    printf("x = %d, y = %d\n", x, y); // 输出仍为 x=5, y=10  
    return 0;  
}  

此时，若希望函数能够修改原变量的值，就需要引入指针。

二、传递指针给函数的语法与原理

2.1 语法结构：用指针参数接收地址

要将指针传递给函数，需在函数声明中定义参数为指针类型。语法格式如下：

返回类型 函数名(数据类型 *指针参数名) {  
    // 函数体  
}  

例如，修改上述 swap_by_value 函数为通过指针交换变量：

void swap_by_pointer(int *a, int *b) {  
    int temp = *a;  
    *a = *b;  
    *b = temp;  
}  
int main() {  
    int x = 5, y = 10;  
    swap_by_pointer(&x, &y);  
    printf("x = %d, y = %d\n", x, y); // 输出 x=10, y=5  
    return 0;  
}  

关键点解析：

• 在调用函数时，需通过 & 运算符获取变量的地址（如 &x）。
• 在函数内部，通过 * 运算符解引用指针，直接操作原变量的值。

2.2 内存模型的直观对比

假设 x 的地址为 0x1000，y 的地址为 0x2000，则函数调用的内存变化如下：
| 阶段 | x 的值 | y 的值 | swap_by_pointer 的参数 a | swap_by_pointer 的参数 b |
|--------------|----------|----------|------------------------------|------------------------------|
| 调用前 | 5 | 10 | 无效 | 无效 |
| 参数传递时 | 5 | 10 | 存储 0x1000 | 存储 0x2000 |
| 函数执行中 | 10 | 5 | 仍为 0x1000 | 仍为 0x2000 |

通过地址操作，函数直接修改了原始变量的值，突破了值传递的限制。

三、传递指针的实际应用场景

3.1 动态内存分配与释放

当函数需要返回动态分配的内存时，必须通过指针参数传递地址。例如：

#include <stdlib.h>  

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

int main() {  
    int *array = NULL;  
    allocate_memory(&array, 5); // 传递指针的地址  
    if (array != NULL) {  
        // 使用分配的内存  
        free(array);  
    }  
    return 0;  
}  

关键点：

• 函数 allocate_memory 需要修改 array 的地址，因此参数类型为 int **，并解引用两次（*ptr）。

3.2 处理大型数据结构（如数组或结构体）

直接传递数组或结构体会导致内存浪费，而传递指针则更高效。例如：

#include <string.h>  

void modify_array(char *str) {  
    strcpy(str, "Hello, C Pointer!"); // 直接修改原数组  
}  

int main() {  
    char buffer[50] = "Original String";  
    modify_array(buffer); // 实际传递 buffer 的首地址  
    printf("%s\n", buffer); // 输出 "Hello, C Pointer!"  
    return 0;  
}  

3.3 实现回调函数或函数指针

在高级编程中，通过传递函数指针，可以实现灵活的函数调用逻辑：

void execute_callback(void (*func_ptr)()) {  
    func_ptr(); // 调用传入的函数  
}  

void print_message() {  
    printf("Callback executed!\n");  
}  

int main() {  
    execute_callback(&print_message); // 传递函数指针  
    return 0;  
}  

四、注意事项与常见误区

4.1 空指针与悬垂指针

• 空指针（Null Pointer）：未初始化的指针可能指向无效地址，导致程序崩溃。

  int *ptr; // 未初始化，可能引发未定义行为  
  *ptr = 10; // 错误！  
  

• 悬垂指针（Dangling Pointer）：指针指向已释放的内存区域。

  int *ptr = (int *)malloc(sizeof(int));  
  free(ptr); // 释放内存后，ptr 成为悬垂指针  
  *ptr = 20; // 未定义行为  
  

4.2 指针与数组的隐式转换

在函数参数中，数组名会隐式转换为指向其首元素的指针。例如：

void print_array(int arr[], int size) {  
    // 实际参数是 int *arr  
}  

因此，无需显式传递数组指针，但需注意数组长度的传递方式。

4.3 指针与结构体的联合使用

通过传递结构体指针，可以高效地操作复杂数据：

struct Point {  
    int x, y;  
};  

void move_point(struct Point *p, int dx, int dy) {  
    p->x += dx;  
    p->y += dy; // 使用结构体指针成员访问运算符 ->  
}  

int main() {  
    struct Point origin = {0, 0};  
    move_point(&origin, 5, 5); // 传递结构体地址  
    return 0;  
}  

五、进阶技巧与性能优化

5.1 指针与多返回值

函数无法直接返回多个值，但通过指针可以实现：

void get_min_max(int arr[], int size, int *min, int *max) {  
    *min = *max = arr[0];  
    for (int i = 1; i < size; i++) {  
        if (arr[i] < *min) *min = arr[i];  
        if (arr[i] > *max) *max = arr[i];  
    }  
}  

5.2 指针与内存对齐

在嵌入式或高性能计算场景中，传递指针时需注意内存对齐要求，以避免因未对齐访问导致的性能下降或错误。

5.3 使用 const 关键字确保安全性

若函数不需要修改指针指向的值，可使用 const 修饰参数：

void print_value(const int *ptr) {  
    printf("%d\n", *ptr);  
    // *ptr = 10; // 编译错误：尝试修改 const 变量  
}  

结论

掌握“C 传递指针给函数”这一技术，能够显著提升程序的灵活性与效率。通过理解指针的本质、参数传递的机制、以及实际应用场景中的最佳实践，开发者可以更从容地应对复杂编程挑战。无论是动态内存管理、结构体操作，还是函数回调，指针传递都是 C 语言中不可或缺的工具。建议读者通过编写实际代码（如实现链表、二叉树或文件操作功能）来巩固这一知识点，逐步从“理解”迈向“精通”。

通过本文的系统讲解，希望读者能够建立起对“C 传递指针给函数”的清晰认知，并在后续的开发中灵活运用这一技术。