FFFire小火1. 指针、数组与函数传参：C语言核心三剑客
在C语言的世界里，指针、数组和函数传参就像三位形影不离的老朋友。它们之间的关系错综复杂却又密不可分，理解它们的互动方式是成为C语言高手的必经之路。我至今记得第一次用指针操作数组时那种"啊哈"的顿悟时刻——原来内存可以这样玩！
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 指针的本质与数组的真相
2.1 指针：内存的导航仪
指针本质上就是一个存储内存地址的变量。在32位系统中它占4字节，64位系统中占8字节。理解指针的关键在于区分指针本身和它指向的内容：
c复制int a = 10;
int *p = &a; // p是指针变量，存储的是a的地址
*p = 20; // 通过指针修改a的值
指针的威力在于它能直接操作内存。比如我们可以用指针遍历数组：
c复制int arr[5] = {1,2,3,4,5};
int *ptr = arr; // 数组名就是首元素地址
for(int i=0; i<5; i++){
printf("%d ", *(ptr+i)); // 指针算术运算
}
2.2 数组：连续内存的伪装者
数组名在大多数情况下会退化为指向首元素的指针。但有两个例外：
- 使用sizeof(arr)时，得到的是整个数组的大小
- 使用&arr时，得到的是整个数组的地址（虽然值相同，但类型不同）
c复制int arr[5] = {0};
printf("%p %p\n", arr, &arr); // 值相同
printf("%zu %zu\n", sizeof(arr), sizeof(&arr)); // 20 vs 8(64位)
多维数组也是如此，int arr[3][4]可以看作"数组的数组"，arr[i]是一个包含4个int的数组。
3. 函数传参的三种姿势
3.1 值传递：最安全的隔离
默认的参数传递方式是值传递，函数得到的是实参的副本：
c复制void swap(int a, int b){
int temp = a;
a = b;
b = temp; // 只交换了副本
}
这种方式安全但效率低，特别是传递大结构体时。
3.2 指针传递：直接操作原数据
通过传递指针，函数可以修改调用者的变量：
c复制void real_swap(int *a, int *b){
int temp = *a;
*a = *b;
*b = temp; // 实际交换了原变量
}
这是C语言中最常用的方式，既能避免数据拷贝，又能修改原数据。
3.3 数组传递：退化的艺术
数组作为参数时总是退化为指针，所以以下三种声明是等价的：
c复制void func(int *arr);
void func(int arr[]);
void func(int arr[10]); // 10会被忽略
因此数组大小信息会丢失，通常需要额外传递大小参数：
c复制void print_array(int arr[], int size){
for(int i=0; i<size; i++){
printf("%d ", arr[i]);
}
}
4. 实战中的经典组合技
4.1 指针数组 vs 数组指针
这是两个容易混淆的概念：
c复制int *ptr_arr[5]; // 指针数组：包含5个int指针的数组
int (*arr_ptr)[5]; // 数组指针：指向包含5个int的数组的指针
使用场景示例：
c复制// 指针数组常用于字符串数组
const char *names[] = {"Alice", "Bob", "Charlie"};
// 数组指针常用于处理二维数组
int matrix[3][4];
int (*ptr)[4] = matrix; // 指向包含4个int的数组
4.2 动态数组的创建与释放
结合指针和malloc可以创建动态数组：
c复制int *create_array(int size){
int *arr = malloc(size * sizeof(int));
if(arr == NULL){
// 错误处理
}
return arr;
}
void free_array(int *arr){
free(arr);
}
记得每次malloc都要有对应的free，否则会导致内存泄漏。
4.3 函数指针：将函数作为参数
函数指针允许我们将函数作为参数传递：
c复制int compare(int a, int b){
return a - b;
}
void sort(int *arr, int size, int (*cmp)(int,int)){
// 使用cmp函数进行比较
for(int i=0; i<size-1; i++){
for(int j=0; j<size-i-1; j++){
if(cmp(arr[j], arr[j+1]) > 0){
// 交换
}
}
}
}
// 调用
sort(arr, 5, compare);
这在实现回调函数、策略模式等场景非常有用。
5. 常见陷阱与调试技巧
5.1 悬垂指针问题
指向已释放内存的指针称为悬垂指针，使用它会导致未定义行为：
c复制int *func(){
int a = 10;
return &a; // 错误！a在函数结束时已销毁
}
int *ptr = malloc(sizeof(int));
free(ptr);
*ptr = 5; // 错误！ptr已成为悬垂指针
5.2 数组越界访问
C不会检查数组边界，越界访问可能导致程序崩溃或更隐蔽的错误：
c复制int arr[5];
arr[5] = 10; // 越界！合法但危险
使用valgrind等工具可以帮助检测这类问题。
5.3 const与指针的复杂关系
const的位置决定了什么被限定：
c复制const int *p1; // 指向const int的指针，不能通过p1修改值
int const *p2; // 同上
int *const p3; // const指针，不能改变指向
const int *const p4; // 指向const int的const指针
理解这些区别对编写健壮的接口很重要。
6. 性能优化实践
6.1 避免不必要的拷贝
对于大结构体，传递指针比传递值更高效：
c复制struct BigStruct { /* 很多字段 */ };
// 不好：会拷贝整个结构体
void process(struct BigStruct bs);
// 好：只传递指针
void process_ptr(const struct BigStruct *bs);
6.2 指针与局部性原理
顺序访问数组比随机访问更高效，因为利用了CPU缓存：
c复制// 好：顺序访问
for(int i=0; i<size; i++){
sum += arr[i];
}
// 不好：随机访问
for(int i=0; i<size; i++){
sum += arr[random_index[i]];
}
6.3 内联函数减少调用开销
对于小型频繁调用的函数，使用inline可以避免函数调用开销：
c复制inline int max(int a, int b){
return a > b ? a : b;
}
但要注意内联会增加代码体积，不宜滥用。
7. 现代C语言的最佳实践
7.1 使用size_t处理大小
size_t是无符号类型，适合表示内存大小和数组索引：
c复制void process_array(int *arr, size_t size){
for(size_t i=0; i<size; i++){
// 更安全的循环
}
}
7.2 智能指针模式
虽然C没有C++的智能指针，但可以模拟：
c复制typedef struct {
int *ptr;
size_t size;
} SmartArray;
SmartArray create_smart_array(size_t size){
SmartArray sa;
sa.ptr = malloc(size * sizeof(int));
sa.size = size;
return sa;
}
void destroy_smart_array(SmartArray *sa){
free(sa->ptr);
sa->ptr = NULL;
sa->size = 0;
}
7.3 静态分析工具
使用clang-tidy、cppcheck等工具可以提前发现许多指针和数组相关的问题：
bash复制clang-tidy --checks=* test.c
cppcheck --enable=all test.c
8. 从理解到精通：我的学习路径建议
掌握指针、数组和函数传参的关键是多写代码。我建议的练习路线：
- 基础练习：实现各种数组操作函数（查找、排序、反转等）
- 中级挑战：用指针实现链表、树等数据结构
- 高级应用：设计支持多种数据类型的通用容器
- 系统编程：使用指针直接操作硬件或系统资源
一个特别有用的练习是重新实现标准库函数，如strcpy、memmove等。这会强迫你深入理解内存操作。
我在学习过程中发现，画内存布局图对理解指针特别有帮助。每次遇到复杂的指针表达式，我都会在纸上画出内存和指针的关系，这比单纯看代码要直观得多。