异常教程
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 语言的世界中，指针（Pointer）如同一把钥匙，既能打开内存管理的大门，也隐藏着许多陷阱。无论是开发操作系统、嵌入式系统，还是编写高性能算法，理解指针的核心原理是每个开发者进阶的必经之路。本文将从基础概念出发，通过直观的比喻、代码示例和实际场景，帮助读者逐步掌握 C 指针 的核心逻辑，同时避免常见的错误。
指针基础：内存地址的“身份证”
1. 内存地址：计算机的“地理坐标”
想象你的电脑内存是一栋巨大的写字楼，每个房间（内存单元）都有一个唯一的编号（地址）。变量在内存中占据特定的房间，而指针就是记录这个房间编号的工具。例如：
int number = 10;
int *p = &number; // p 存储了 number 的地址
&number表示“取变量 number 的地址”，返回的是一个内存地址值。*p表示“p 是一个指针变量”，其类型为int的地址。
2. 指针的声明与初始化
指针的声明遵循“类型*指针名”的语法：
int *p; // 声明一个指向 int 类型的指针
char *str; // 声明一个指向字符的指针
初始化指针时，必须赋予其一个有效地址：
int a = 20;
p = &a; // 正确：p 指向 a 的地址
str = "Hello"; // 正确：字符串常量的地址赋值
3. 解引用（Dereferencing）与地址运算
通过 * 运算符可以访问指针指向的内存内容：
*p = 30; // 将 a 的值改为 30
printf("%d", *p); // 输出 30
若尝试解引用一个未初始化的指针（如 *p 未指向有效地址），会导致程序崩溃。
指针与内存管理：动态资源的“管家”
1. 堆与栈：内存的两种“仓库”
- 栈（Stack）：由编译器自动管理，存储局部变量。变量生命周期随函数调用结束而销毁。
- 堆（Heap）：需要手动分配和释放，通过
malloc、calloc、realloc、free等函数操作。
2. 动态内存分配
int *dynamic_array = (int*)malloc(5 * sizeof(int)); // 分配 5 个 int 大小的内存
if (dynamic_array == NULL) {
printf("内存分配失败！\n");
} else {
dynamic_array[0] = 100; // 使用分配的内存
free(dynamic_array); // 释放内存，避免内存泄漏
}
注意：分配内存后必须检查 NULL，且 free 只能释放由 malloc 系列函数分配的内存。
3. 内存泄漏与悬挂指针
- 内存泄漏：忘记释放不再使用的内存，导致程序占用过多资源。
- 悬挂指针（Dangling Pointer）：指针指向已被释放的内存，访问时会引发未定义行为。
指针的常见操作：灵活的“工具箱”
1. 指针算术：内存地址的“导航仪”
指针可以像数字一样进行加减运算，但结果会根据类型自动缩放：
int arr[3] = {1, 2, 3};
int *ptr = arr; // ptr 指向 arr[0]
printf("%d", *(ptr + 1)); // 输出 2，相当于 arr[1]
关键点：ptr + 1 的结果是 ptr 的地址加上 sizeof(int) 的大小。
2. 指针比较：地址的“比对”
指针可以比较是否指向同一地址：
int a = 5, b = 5;
int *p = &a, *q = &b;
printf("%d", p == q); // 输出 0，因为 a 和 b 的地址不同
但不能比较不同数据类型的指针（如 int* 和 char*）。
3. 空指针（Null Pointer）
空指针表示“不指向任何有效地址”：
int *null_ptr = NULL; // 定义空指针
if (p != NULL) {
// 安全访问指针
}
高级指针用法：进阶的“超能力”
1. 多级指针：指针的“指针”
多级指针用于修改指针的指向：
void modify_pointer(int **pp) {
int new_value = 100;
*pp = &new_value; // 修改 pp 指向的指针
}
int main() {
int *p = NULL;
modify_pointer(&p); // 传递 p 的地址
printf("%d", *p); // 输出 100
return 0;
}
2. 指针与结构体：对象的“引用”
结构体指针可以高效操作复杂数据：
struct Person {
char name[20];
int age;
};
void print_info(struct Person *p) {
printf("Name: %s, Age: %d\n", p->name, p->age); // 使用 -> 运算符
}
3. 函数指针：行为的“引用”
函数指针指向函数的入口地址，支持动态调用：
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int main() {
int (*func_ptr)(int, int) = add; // 指向 add 函数
printf("%d", func_ptr(5, 3)); // 输出 8
func_ptr = subtract; // 改变指向
return 0;
}
实战案例：指针的“真实世界”应用
案例 1：动态数组的实现
#include <stdio.h>
#include <stdlib.h>
void resize_array(int **arr, int *size, int new_size) {
int *new_arr = (int*)malloc(new_size * sizeof(int));
if (new_arr == NULL) return;
// 复制旧数据
for (int i = 0; i < *size; i++) {
new_arr[i] = (*arr)[i];
}
free(*arr); // 释放旧内存
*arr = new_arr; // 更新指针
*size = new_size;
}
int main() {
int *dynamic_array = NULL;
int current_size = 0;
resize_array(&dynamic_array, ¤t_size, 3); // 分配 3 个元素
// ... 使用动态数组 ...
free(dynamic_array);
return 0;
}
案例 2：链表的遍历
struct Node {
int data;
struct Node *next;
};
void print_list(struct Node *head) {
while (head != NULL) {
printf("%d -> ", head->data);
head = head->next; // 移动指针到下一个节点
}
printf("NULL\n");
}
结论：平衡力量与责任
指针是 C 语言的“双刃剑”——它赋予开发者直接操作内存的自由，但也要求开发者承担内存安全的责任。通过理解指针的本质（内存地址的引用）、掌握动态内存管理（分配与释放）、避免常见陷阱（如未初始化指针），开发者可以更高效地利用 C 指针 的能力，写出高性能且稳定的代码。
实践建议：
- 使用
valgrind或内存分析工具检测内存泄漏。 - 为指针添加注释，明确其指向的内存类型和生命周期。
- 从简单项目（如动态数组、链表）开始练习，逐步挑战复杂场景。
掌握指针不仅是技术的提升，更是对计算机底层逻辑的深刻理解。通过循序渐进的实践，你将解锁 C 语言最核心的“超能力”。