异常教程

C 传递数组给函数（一文讲透）

更新时间:

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

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

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

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

在 C 语言编程中，数组是存储和操作数据的重要工具。当我们需要对一组数据进行统一处理时，将数组传递给函数是一种高效且模块化的设计方式。然而，由于 C 语言本身的特性，数组传递的实现机制与普通变量有所不同。本文将从基础概念出发，结合实际案例，逐步解析如何在 C 语言中正确传递数组给函数，并探讨其背后的核心原理。

理解数组的底层存储与传递机制

数组在内存中的存储形式

数组在内存中是一段连续的存储空间，每个元素占据固定大小的内存单元。例如，一个包含 5 个整数的数组 int arr[5]，在内存中表现为 5 个连续的 4 字节（假设 int 占用 4 字节）空间。这种连续性使得数组操作高效，但同时也对函数传递提出了特殊要求。

比喻说明：
可以将数组想象为一排紧密排列的抽屉，每个抽屉对应一个数组元素。当需要将整排抽屉“传递”给函数时，函数需要知道抽屉的起始位置和总数量，才能正确操作所有抽屉。

函数参数传递的底层逻辑

C 语言中，函数参数的传递通常遵循“按值传递”原则，即函数内部操作的是参数的副本。但数组作为特殊类型，其传递方式与普通变量不同：

  • 数组名退化为指针：当数组名作为参数传递时，它会退化为指向数组首元素的指针（即地址值）。
  • 丢失数组长度信息：函数接收到的指针仅包含首地址，而原始数组的大小信息会被丢弃。

关键结论：
传递数组给函数时，本质上是传递了一个指向数组起始位置的指针，因此函数内部无法直接获取数组的长度。

数组传递的语法与参数声明

基础语法：指针与数组参数的等价性

在函数参数声明时，C 语言允许两种等价的语法形式：

void process_array(int arr[], int size);  
void process_array(int *ptr, int size);

两者完全相同，因为 int arr[] 在参数声明时会被编译器视为 int *arr。

注意事项：

  • 如果在函数声明中写成 void process_array(int arr[10])，数组长度 10 会被忽略，仍视为指针类型。
  • 数组的大小信息必须通过额外参数（如 size）显式传递。

传递多维数组的特殊语法

对于二维数组，参数声明需保留至少一维的大小。例如：

void process_2d_array(int matrix[][3], int rows);

这里 [3] 表示列数，必须在参数中明确指定，否则会导致编译器无法计算元素的正确地址。

实际应用场景与代码示例

场景 1：统计数组元素之和

问题描述：编写一个函数，计算数组中所有元素的总和。

代码实现：

#include <stdio.h>  

int calculate_sum(int arr[], int size) {  
    int sum = 0;  
    for (int i = 0; i < size; i++) {  
        sum += arr[i];  
    }  
    return sum;  
}  

int main() {  
    int numbers[] = {10, 20, 30, 40, 50};  
    int size = sizeof(numbers) / sizeof(numbers[0]);  
    printf("Sum: %d\n", calculate_sum(numbers, size));  
    return 0;  
}

关键点解析：

  • sizeof(numbers) / sizeof(numbers[0]) 计算数组长度，这是 C 语言中常用的技巧。
  • 函数内部通过指针遍历数组元素，但必须依赖外部传入的 size 参数控制循环范围。

场景 2：修改数组元素的函数

问题描述：编写一个函数，将数组中的每个元素乘以 2。

代码实现：

void double_elements(int arr[], int size) {  
    for (int i = 0; i < size; i++) {  
        arr[i] *= 2; // 直接修改数组元素  
    }  
}  

int main() {  
    int data[] = {1, 2, 3, 4, 5};  
    int size = sizeof(data) / sizeof(data[0]);  
    double_elements(data, size);  
    for (int i = 0; i < size; i++) {  
        printf("%d ", data[i]); // 输出：2 4 6 8 10  
    }  
    return 0;  
}

核心原理：
由于函数接收的是数组的首地址（指针），对 arr[i] 的修改会直接作用于原始数组。这与普通变量的按值传递截然不同，因此需要特别注意副作用。

高级技巧与常见误区

技巧 1：使用 const 限定符确保安全性

若函数不需要修改数组内容，可将参数声明为 const 类型，防止误操作：

void print_array(const int arr[], int size) {  
    for (int i = 0; i < size; i++) {  
        printf("%d ", arr[i]); // 正确  
        // arr[i] = 0; // 编译报错，因 arr 是常量指针  
    }  
}

技巧 2：动态数组与 malloc 的结合

当使用 malloc 动态分配数组时，传递方式与静态数组完全一致：

int main() {  
    int *dynamic_arr = malloc(5 * sizeof(int));  
    // 初始化并填充数据  
    process_array(dynamic_arr, 5); // 传递动态数组  
    free(dynamic_arr);  
    return 0;  
}

常见误区：忽略数组长度的传递

错误示例：

void bad_function(int arr[]) {  
    // 编译器无法推断数组长度，可能导致越界访问  
    for (int i = 0; i < 100; i++) {  
        printf("%d", arr[i]); // 高风险！  
    }  
}

解决方案：始终通过参数显式传递数组长度。

二维数组的传递与处理

场景：矩阵转置

问题描述：实现一个函数，将二维数组（矩阵）转置。

代码实现：

void transpose_matrix(int matrix[][3], int rows, int cols) {  
    for (int i = 0; i < rows; i++) {  
        for (int j = i + 1; j < cols; j++) {  
            int temp = matrix[i][j];  
            matrix[i][j] = matrix[j][i];  
            matrix[j][i] = temp;  
        }  
    }  
}  

int main() {  
    int mat[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};  
    transpose_matrix(mat, 3, 3);  
    // 输出转置后的矩阵  
    return 0;  
}

注意事项：

  • 参数声明 int matrix[][3] 必须指定第二维的大小，否则编译器无法计算元素的正确地址。
  • 若矩阵是动态分配的，需确保传递正确的行数和列数。

性能与内存优化建议

优化策略 1：避免不必要的数组拷贝

由于数组传递仅传递指针，函数内部操作的是原始数据，因此无需担心内存拷贝的开销。例如，处理大型数组时，直接传递指针比拷贝整个数组更高效。

优化策略 2：使用宏或结构体辅助

对于频繁操作的数组，可结合宏或结构体简化代码：

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))  

struct Array {  
    int *data;  
    int size;  
};  

void process_struct(struct Array arr) {  
    // 直接使用 arr.data 和 arr.size  
}

结论

掌握 C 语言中数组传递的机制，是编写高效、可维护代码的关键。通过本文的讲解，读者可以：

  1. 理解数组传递的本质是“指针传递”，并学会通过额外参数传递长度信息；
  2. 掌握一维和二维数组传递的语法细节；
  3. 通过实际案例巩固知识，并规避常见错误；
  4. 结合 const 限定符和结构体等工具提升代码安全性与可读性。

C 语言的灵活性赋予了程序员高度的控制权，但也需要开发者对底层机制保持清醒认知。希望本文能帮助读者在后续开发中更自信地运用数组传递技术，解决实际问题。

最新发布

查看更多文章