指针&内存&函数
C语言核心概念深度剖析讲义
一、程序内存模型：一切的基础
要理解C语言的各种特性，必须首先掌握程序运行时的内存布局。C程序的内存主要分为以下几个区域：
高地址
┌─────────────────┐
│ 栈区 │ ← 自动变量、函数参数、VLA（自动管理）
│ (Stack) │
├─────────────────┤
│ ↓ │
│ ↑ │
├─────────────────┤
│ 堆区 │ ← malloc/calloc/realloc分配（手动管理）
│ (Heap) │
├─────────────────┤
│ 未初始化数据区 │ ← 全局变量、静态变量（.bss段）
│ (BSS段) │
├─────────────────┤
│ 已初始化数据区 │ ← 全局变量、静态变量（.data段）
│ (数据段) │
├─────────────────┤
│ 代码区 │ ← 程序指令（只读）
│ (文本段) │
低地址
关键理解：不同的内存区域决定了变量的生命周期、作用域和访问特性。栈内存自动管理但空间有限，堆内存手动管理但空间大且灵活。
二、指针：内存的导航系统
2.1 指针的本质
指针是存储内存地址的变量，它提供了直接操作内存的能力。
int a = 10;
int *p = &a; // p是指向a的指针
// 指针的两种基本操作
printf("地址: %p\n", p); // 取地址
printf("值: %d\n", *p); // 解引用
2.2 指针声明的辨析（重点难点）
int *p; // 指向整数的指针
int *p[5]; // 指针数组：包含5个整数指针的数组
int (*p)[5]; // 数组指针：指向包含5个整数的数组的指针
int **p; // 指向指针的指针：多级间接引用
记忆口诀：从变量名开始，先看括号()，再看方括号[]，最后看星号*。
2.3 指针算术运算
指针运算以所指向类型的大小为步长：
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;
printf("%d\n", *p); // 10
printf("%d\n", *(p + 1)); // 20（地址增加sizeof(int)字节）
printf("%d\n", p[2]); // 30（等价于*(p+2)）
三、数组与指针的等价性
3.1 数组名的双重身份
int arr[5] = {1, 2, 3, 4, 5};
// 数组名在大多数情况下退化为指向首元素的指针
printf("%p == %p\n", arr, &arr[0]); // 地址相同
// 但sizeof操作时表现不同
printf("sizeof(arr): %zu\n", sizeof(arr)); // 整个数组大小：20字节
printf("sizeof(&arr[0]): %zu\n", sizeof(&arr[0])); // 指针大小：8字节（64位）
3.2 多维数组的指针表示
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
// 三种访问方式等价
printf("%d\n", matrix[1][2]); // 传统下标：7
printf("%d\n", *(*(matrix + 1) + 2)); // 指针算术：7
printf("%d\n", (*(matrix + 1))[2]); // 混合写法：7
四、动态内存管理
4.1 malloc/free：堆内存管理
#include <stdlib.h>
// 分配内存
int *arr = (int*)malloc(10 * sizeof(int));
if (arr == NULL) {
// 必须检查分配是否成功
printf("内存分配失败\n");
return -1;
}
// 使用内存
for (int i = 0; i < 10; i++) {
arr[i] = i * i;
}
// 释放内存
free(arr);
arr = NULL; // 避免野指针
4.2 变长数组（VLA）与malloc的对比
| 特性 | 变长数组（VLA） | malloc/free |
|---|---|---|
| 内存区域 | 栈区 | 堆区 |
| 生命周期 | 自动（作用域结束即释放） | 手动（需显式调用free） |
| 大小限制 | 受栈大小限制（通常几MB） | 受系统内存限制（很大） |
| 初始化 | 不能显示初始化 | 可配合calloc初始化为0 |
| 性能 | 分配速度快 | 分配速度相对慢 |
| 适用场景 | 小数据量、临时使用 | 大数据量、长期存在 |
// VLA示例：栈上分配
void process_data(int n) {
int vla[n]; // 在栈上分配变长数组
for (int i = 0; i < n; i++) {
vla[i] = i;
}
// 函数结束时自动释放
}
// malloc示例：堆上分配
int* create_array(int n) {
int *arr = malloc(n * sizeof(int));
// 需要手动管理生命周期
return arr; // 可以返回给调用者继续使用
}
五、函数参数传递机制
5.1 传值 vs 传地址
// 传值：无法修改实参
void swap_by_value(int a, int b) {
int temp = a;
a = b;
b = temp; // 只修改形参，不影响实参
}
// 传地址：可以修改实参
void swap_by_reference(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp; // 通过指针修改实参的值
}
int main() {
int x = 10, y = 20;
swap_by_value(x, y); // x,y不变
swap_by_reference(&x, &y); // x,y的值被交换
return 0;
}
5.2 数组/指针作为函数参数
// 三种等价的函数声明
void process_array(int arr[], int size);
void process_array(int *arr, int size);
void process_array(int arr[10], int size); // 10被编译器忽略
// 多维数组作为参数（必须指定第二维）
void process_matrix(int mat[][4], int rows);
void process_matrix(int (*mat)[4], int rows); // 等价写法
六、高级主题与最佳实践
6.1 const关键字与指针
const int *p; // 指向常量的指针：不能通过p修改数据
int *const p; // 常量指针：指针本身不能指向其他地址
const int *const p; // 指向常量的常量指针：两者都不能修改
// 应用：保护函数参数不被修改
void read_only_function(const int *arr, int size) {
// arr[i] = 10; // 错误：不能修改const数据
int value = arr[0]; // 但可以读取
}
6.2 内存操作相关函数
#include <string.h>
// 内存设置
memset(arr, 0, sizeof(arr)); // 将内存块设置为特定值
// 内存拷贝
memcpy(dest, src, n * sizeof(int)); // 拷贝内存块
// 内存比较
if (memcmp(arr1, arr2, n * sizeof(int)) == 0) {
printf("内存内容相同\n");
}
七、综合应用示例：大整数乘法
char *multiply(char *num1, char *num2) {
int n = strlen(num1), m = strlen(num2);
int *result = calloc(n + m, sizeof(int));
// 实现大整数乘法算法
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
int mul = (num1[i] - '0') * (num2[j] - '0');
int sum = result[i + j + 1] + mul;
result[i + j + 1] = sum % 10;
result[i + j] += sum / 10;
}
}
// 转换为字符串返回
return convert_to_string(result, n + m);
}
八、总结：C语言内存管理哲学
- 理解内存布局是掌握C语言的基础
- 指针是C语言的灵魂，提供了直接操作内存的能力
- 数组与指针的等价性是理解复杂声明的关键
- 动态内存管理需要在灵活性和复杂性之间权衡
- const正确性是编写健壮代码的重要保障
- 始终检查返回值，特别是malloc等可能失败的函数
通过深入理解这些核心概念，您将能够编写出高效、健壮的C语言程序，真正掌握这门接近硬件的编程语言。
浙公网安备 33010602011771号