1. 项目概述为什么指针是C/C的“灵魂”如果你刚接触C或C听到“指针”这个词可能会觉得它既神秘又危险像是编程世界里的一个“禁区”。很多教程会告诉你指针是C/C中最难、最容易出错的部分。这话没错但只说对了一半。另一半的真相是指针是C/C赋予程序员最强大的武器是理解这门语言内存模型、写出高效且灵活代码的基石。你可以不会用指针写复杂的链表但如果你想真正理解程序在计算机里是如何运行的想从“写代码的人”变成“驾驭计算机的人”指针是绕不开的坎。我刚开始学C语言时也被*和搞得晕头转向觉得数组用下标访问不是挺好吗为什么非要折腾指针直到后来需要处理动态数据结构、操作硬件寄存器或者优化一段性能瓶颈代码时才恍然大悟没有指针这些事要么做不了要么做得极其笨拙。指针让你能直接和内存“对话”精确地控制每一个字节。这就像开车数组是自动挡指针是手动挡。自动挡简单安全但手动挡能让你更了解车的性能在特定路况下比如陡坡、泥地有更强的操控力。网络上关于指针的讨论一直很热从“找不到c/c编辑器设置”这样的环境配置问题到“智能指针”、“函数指针”、“指针的指针”等进阶概念再到“指针在单片机中的应用”这样的具体场景都说明了它的核心地位和广泛适用性。很多人卡在第一步——环境。比如用VSCode时经常遇到“* 正在执行任务: c/c: gcc.exe 生成活动文件”这样的提示本质就是编译链接过程而这个过程处理的核心对象之一就是各种符号变量、函数的地址也就是指针的雏形。所以理解指针也能帮你更好地理解编译、链接乃至程序加载运行的整个过程。这篇文章我会从一个十几年老码农的视角带你重新认识指针。我们不搞教科书式的平铺直叙而是从内存这个最底层的视角切入把指针的“为什么”讲透。你会看到那些令人困惑的*a、a、**p其实都对应着内存中一个个清晰的位置。我们还会深入到函数指针、动态内存管理并重点探讨现代C中如何用智能指针安全地驾驭指针这把“双刃剑”。目标是让你不仅知道指针怎么用更明白为什么要这么用以及如何用得安全、高效。2. 内存视角理解指针的底层逻辑要理解指针必须暂时忘掉“变量名”直接看向计算机的内存。你可以把内存想象成一个超大的、带编号的储物柜阵列。每个储物柜内存单元大小固定通常是1字节并且有一个唯一的编号这个编号就是内存地址。2.1 变量、地址与指针值当我们声明一个变量时比如int a 10;编译器会做两件事在内存中找一块连续且足够大的空闲“储物柜”对于int通常是4个柜子用来存放值10。把这块区域的起始地址和变量名a关联起来记在自己的小本本符号表上。之后我们在代码里写a 20;编译器就会根据名字a找到对应的地址然后去那个地址对应的储物柜里把原来的10换成20。那么指针是什么呢指针本身也是一个变量只不过这个变量里存储的不是普通的数值如10、3.14而是另一个变量的内存地址。int a 10; // 假设变量a存放在地址 0x7ffeed0a 开始的内存中 int *p a; // 指针变量p里面存储的值是 a 的地址 0x7ffeed0a这里是取地址运算符它获取变量a的“储物柜编号”地址。int *是声明它告诉编译器p是一个指针它将来要指向一个int类型数据所在的地址。所以p这个指针变量自己也有一个地址比如0x7ffeed12它里面存放的值是0x7ffeed0a即a的地址。这就形成了两层关系理解这两层关系是理解所有指针操作的关键。注意一个常见的误解是认为*p就是指针本身。不对。p是指针变量里面存着地址*p是解引用操作意思是“去p里存的地址那里把里面的值拿出来”。所以*p等价于a。2.2 指针的类型不仅仅是地址为什么指针声明时要带类型比如int *、char *既然指针存的都是地址一个数字类型有什么用类型的作用极其重要它决定了解引用时的操作粒度int *p;告诉编译器*p操作会从目标地址开始读取/写入sizeof(int)个字节通常是4字节。而char *q;则只操作1个字节。如果类型不匹配就会导致数据读写错误。指针算术运算的步长p 1并不是地址值简单加1而是加上sizeof(int)。因为p指向一个int下一个int在内存中相隔4个字节。这对于数组遍历和内存偏移计算至关重要。int arr[5] {1, 2, 3, 4, 5}; int *p arr; // p指向数组首元素即arr[0]的地址 printf(%d\n, *p); // 输出 1 printf(%d\n, *(p 2)); // 输出 3。 p2 相当于地址增加了 2 * sizeof(int) 8字节实操心得当你看到一个指针定义比如float *fp;立刻在心里明确三件事1)fp本身占一块内存存放地址2)fp里存的地址指向一块至少4字节(sizeof(float))的内存区域3) 通过*fp操作的就是那块区域里的浮点数。这个思维模型能帮你理清绝大多数指针问题。2.3 指针的大小一个容易混淆的点在同一个平台上所有数据指针int *char *struct MyStruct *的大小通常是相同的因为它们存储的都是内存地址。这个大小取决于系统的寻址能力在32位系统上地址是32位所以指针大小通常是4字节。在64位系统上地址是64位所以指针大小通常是8字节。 你可以用sizeof(void *)来验证。但是函数指针的大小可能和数据指针不同这取决于具体的编译器和平台。不过在大多数常见环境下可以认为它们大小相同。踩坑记录曾经在嵌入式平台16位单片机上遇到过数据指针和函数指针大小不一致的情况导致用memcpy拷贝函数指针时溢出。所以在涉及函数指针的底层操作时最好先查一下编译器手册。3. 核心操作声明、初始化、解引用与算术指针的基本操作看似简单但每个细节都藏着坑。我们系统过一遍。3.1 声明与初始化避免野指针声明一个指针只是告诉编译器它的类型并没有为它分配一个有效的指向目标。int *p; // 危险p的值是未定义的垃圾值是一个“野指针”绝对不要解引用一个未初始化或为NULL的指针NULL在C11后建议使用nullptr。这会导致未定义行为通常就是程序崩溃段错误。安全的初始化方式// 方法1初始化为空指针 int *p1 nullptr; // C11以上最推荐 int *p2 NULL; // C或老式C int *p3 0; // 字面值0在指针上下文里也是空指针 // 方法2指向一个已存在的变量 int value 42; int *p4 value; // 方法3指向动态分配的内存 int *p5 new int(42); // C int *p6 (int*)malloc(sizeof(int)); // C, 记得初始化 *p6 *p6 42;常见问题为什么有时候声明指针int* p, q;只有p是指针q是int因为*是绑定到变量名而不是类型。int* p, q;等价于int *p; int q;。想声明两个指针必须写成int *p, *q;。我个人习惯将*紧挨变量名int *p这样语义更清晰。3.2 解引用获取指针所指的值解引用操作符*是单向通道的“钥匙”。从“值”到“地址”。*从“地址”到“值”。int a 10; int *p a; printf(%d\n, a); // 输出 10直接访问值 printf(%p\n, a); // 输出 a 的地址 (如 0x7ffee...) printf(%p\n, p); // 输出 p 存储的值即 a 的地址 printf(%d\n, *p); // 输出 10解引用p获取它指向地址的值 *p 20; // 解引用并赋值等价于 a 20; printf(%d\n, a); // 输出 203.3 指针的算术运算在内存中漫步指针的加减运算单位是“指向类型的大小”而不是字节。这使它成为遍历数组的天然工具。int arr[] {10, 20, 30, 40, 50}; int *ptr arr; // ptr 指向 arr[0] printf(%d\n, *ptr); // 10 ptr; // ptr 现在指向 arr[1]地址增加了 sizeof(int) printf(%d\n, *ptr); // 20 ptr ptr 3; // ptr 现在指向 arr[4] printf(%d\n, *ptr); // 50 // 指针相减得到的是元素个数差而不是字节差 int *p1 arr[1]; int *p2 arr[4]; printf(%td\n, p2 - p1); // 输出 3 (long long 类型用 %td 打印)重要限制指针相加 (ptr1 ptr2) 没有意义不允许。指针乘除运算不允许。指针运算必须发生在指向同一连续内存块如同一个数组的指针之间否则行为未定义。实操技巧用指针遍历数组通常比下标更快某些编译器优化后可能无差别但可读性稍差。在性能敏感的循环中可以考虑。例如for(int *it arr; it ! arr 5; it) { printf(%d , *it); }4. 指针与数组剪不断理还乱的关系C/C中数组和指针的关系极其密切以至于常常被混淆但它们有本质区别。4.1 数组名是什么在大多数表达式中数组名会退化成指向其首元素的指针。int arr[5] {1,2,3,4,5}; int *p arr; // 正确arr 退化为 arr[0]这里arr的类型是int[5]但在赋值给p时它退化成了int*。但是有两个例外数组名不会退化sizeof(arr)返回的是整个数组的字节大小5 * sizeof(int)而不是指针大小。arr取到的是“整个数组”的地址其类型是int(*)[5]指向含5个int的数组的指针。虽然值和arr[0]相同但类型不同指针运算的步长不同arr 1会跳过整个数组。4.2 数组访问的本质下标操作arr[i]在编译器看来完全等价于*(arr i)。这就是为什么你可以用指针语法访问数组也可以用数组语法访问指针只要它指向数组元素。int arr[3] {100, 200, 300}; int *p arr; printf(%d\n, arr[1]); // 200 printf(%d\n, *(arr 1)); // 200 printf(%d\n, p[1]); // 200 等价于 *(p 1) printf(%d\n, *(p 1)); // 200注意事项虽然arr[i]和i[arr]在语法上居然都合法因为*(arri)和*(iarr)等价但后者纯粹是语法游戏绝对不要用在生产代码中会严重降低可读性。4.3 指针数组 vs. 数组指针这是两个容易混淆的概念关键在于看最后那个词是什么。指针数组首先它是一个数组数组里的每个元素都是指针。int *ptr_array[10]; // 一个包含10个 int* 类型元素的数组数组指针首先它是一个指针这个指针指向一个数组。int (*array_ptr)[10]; // 一个指针指向一个包含10个int的数组 int big_array[5][10]; array_ptr big_array; // 指向 big_array 的第一行一个包含10个int的数组记忆口诀从变量名开始向右看再向左看。int *p[10]先看到[10]说明p是个数组再向左看到*说明数组元素是指针最后看到int说明指针指向int。所以是指针数组。int (*p)[10]括号优先*p说明p是个指针再看右边[10]说明指针指向一个大小为10的数组最后看左边int说明数组元素是int。所以是数组指针。5. 多级指针与指针的指针指针可以指向任何类型的数据包括另一个指针。这就是多级指针例如int **pp。5.1 为什么需要指针的指针主要应用场景动态二维数组在堆上分配一个“指针数组”每个指针再指向一个“数据数组”。在函数中修改传入的指针C语言函数参数是值传递。如果你想修改一个指针变量本身比如在函数内为它分配内存就需要传递这个指针的地址即指针的指针。字符串数组argvmain函数的char *argv[]参数本质上就是一个指针数组传递时退化成char **argv。5.2 理解**pp的内存模型int value 42; int *p value; // p 存储 value 的地址 int **pp p; // pp 存储 p 的地址内存关系pp一个int**变量存储着p的地址。p一个int*变量存储着value的地址。value一个int变量存储着42。访问过程*pp解引用pp得到p即value的地址。**pp等价于*(*pp)。先解引用pp得到p再解引用p得到value的值42。5.3 在函数中分配内存的经典案例这是多级指针最实用、也最容易出错的地方。// 错误示例无法在函数内部分配内存给外部指针 void allocate_memory_wrong(int *ptr) { ptr (int*)malloc(sizeof(int) * 10); // 修改的是形参ptr的副本 // 函数返回后外部的实参指针没有任何变化 } // 正确示例使用二级指针 void allocate_memory_right(int **ptr) { *ptr (int*)malloc(sizeof(int) * 10); // 解引用二级指针修改外部的一级指针 if (*ptr ! NULL) { (*ptr)[0] 100; // 注意运算符优先级下标[]高于*需要括号 } } int main() { int *my_array NULL; allocate_memory_wrong(my_array); // 调用后my_array 仍然是 NULL // allocate_memory_right(my_array); // 正确传递指针的地址 // 现在 my_array 指向了堆上分配的10个int空间 // ... 使用 my_array free(my_array); // 不要忘记释放 return 0; }避坑指南使用二级指针时要格外注意运算符优先级。*ptr[i]会被解释为*(ptr[i])而(*ptr)[i]才是我们通常想要的意思。不确定时就加括号。6. 函数指针将函数作为数据传递函数指针顾名思义是指向函数的指针。它允许你将函数像数据一样存储、传递和调用是实现回调、策略模式等高级技巧的基础。6.1 声明与使用函数指针函数指针的声明有点复杂记住一个窍门先写出普通函数声明再把函数名替换成(*指针变量名)。// 一个普通函数 int add(int a, int b) { return a b; } // 对应的函数指针声明 int (*func_ptr)(int, int); // func_ptr 是一个指针指向一个返回int接受两个int参数的函数 // 赋值 func_ptr add; // 可选函数名本身也会退化为函数地址 func_ptr add; // 与上一行等价 // 调用 int result1 (*func_ptr)(3, 4); // 传统解引用调用 int result2 func_ptr(3, 4); // 简化调用更常见 printf(%d\n, result2); // 输出 76.2 函数指针的典型应用回调函数回调函数是函数指针最经典的应用。库函数或框架提供一个接口允许你传入一个自定义的函数回调函数在特定时刻由库来调用。// 库提供的排序函数接口模拟qsort的部分思想 void sort_array(int *array, int size, int (*compare)(int, int)) { // ... 排序算法内部 ... // 当需要比较两个元素 array[i] 和 array[j] 时 if (compare(array[i], array[j]) 0) { // 交换 } // ... } // 用户提供的回调函数1升序比较 int compare_asc(int a, int b) { return a - b; } // 用户提供的回调函数2降序比较 int compare_desc(int a, int b) { return b - a; } int main() { int arr[] {5, 1, 8, 3}; // 使用升序回调 sort_array(arr, 4, compare_asc); // 使用降序回调 // sort_array(arr, 4, compare_desc); // ... }这样sort_array函数就与具体的比较逻辑解耦了变得非常通用。6.3 使用typedef简化复杂声明复杂的函数指针声明可读性很差。使用typedef可以创建别名大大简化代码。// 未使用 typedef void (*signal(int sig, void (*func)(int)))(int); // 这是一个函数声明看不懂吧 // 使用 typedef 分解 typedef void (*sighandler_t)(int); // 定义了一个类型指向 void (int) 函数的指针 sighandler_t signal(int sig, sighandler_t func); // 现在清晰多了实操心得在定义包含函数指针的结构体或者需要将函数指针作为参数频繁传递时typedef是必需品。它能显著提升代码的可读性和可维护性。7. 动态内存管理指针的主战场指针的强大在动态内存管理上体现得淋漓尽致。它允许程序在运行时而不是编译时申请和释放任意大小的内存。7.1 C风格malloc,calloc,realloc,free这是C语言的标准库函数在C中也可以用但通常不推荐应使用new/delete。#include stdlib.h // 1. malloc - 分配指定字节数的未初始化内存 int *p1 (int*)malloc(10 * sizeof(int)); // 分配10个int的空间 if (p1 NULL) { /* 处理分配失败 */ } // p1 指向的内存内容是未定义的垃圾值 // 2. calloc - 分配并清零内存 int *p2 (int*)calloc(10, sizeof(int)); // 分配10个int的空间并全部初始化为0 if (p2 NULL) { /* 处理分配失败 */ } // 3. realloc - 调整已分配内存块的大小 p1 (int*)realloc(p1, 20 * sizeof(int)); // 将p1指向的内存扩大到20个int if (p1 NULL) { /* 处理失败注意原指针p1可能已失效 */ } // 4. free - 释放内存 free(p1); free(p2); p1 p2 NULL; // 好习惯释放后立即置空防止“悬空指针”关键注意事项检查返回值malloc/calloc/realloc可能失败返回NULL。不检查就使用会导致崩溃。匹配使用malloc分配的内存用free释放。new分配的内存用delete释放。混用行为未定义。不要重复释放对同一个指针free两次是严重错误。realloc的陷阱realloc可能返回一个新的地址。如果失败它返回NULL但原内存块并未释放。错误的写法ptr realloc(ptr, new_size);会导致内存泄漏当失败时。正确做法是使用临时指针int *temp (int*)realloc(ptr, new_size); if (temp ! NULL) { ptr temp; // 成功更新指针 } else { // 处理失败原ptr指向的内存仍然有效需要后续释放 }7.2 C风格new与deleteC 引入了运算符new和delete更安全、更符合面向对象的思想。// 1. 分配单个对象 int *p_single new int(42); // 分配一个int并初始化为42 delete p_single; // 释放 p_single nullptr; // 2. 分配对象数组 int *p_array new int[10]; // 分配10个int的数组对于基本类型未初始化 delete[] p_array; // 必须使用 delete[] 来匹配 new[] p_array nullptr; // 3. 分配并初始化数组 (C11起) int *p_array_init new int[10]{1,2,3}; // 前三个元素初始化为1,2,3其余为0 delete[] p_array_init; // 4. 分配类对象 class MyClass { /* ... */ }; MyClass *obj new MyClass(); // 调用构造函数 delete obj; // 调用析构函数new相对于malloc的优势类型安全new返回正确类型的指针无需强制转换。调用构造函数/析构函数对于类对象new会调用构造函数delete会调用析构函数。malloc/free不会。可重载可以为自定义类重载new/delete运算符实现自定义内存管理。核心规则new对应delete。new[]对应delete[]。绝对不能混用。用new[]分配数组却用delete释放行为未定义通常会导致内存布局信息错乱可能崩溃或泄漏。8. 智能指针现代C的安全管家手动管理内存new/delete非常容易出错忘记释放导致内存泄漏或提前释放导致悬空指针。现代CC11起引入了智能指针它们位于memory头文件中通过RAII资源获取即初始化机制自动管理动态对象的生命周期。8.1std::unique_ptr独占所有权的智能指针一个unique_ptr独占它所指向的对象。它不能被复制只能被移动。当unique_ptr离开作用域时它会自动删除其管理的对象。#include memory #include iostream class Widget { public: Widget() { std::cout Widget constructed.\n; } ~Widget() { std::cout Widget destroyed.\n; } void doSomething() { std::cout Widget working.\n; } }; void test_unique() { std::unique_ptrWidget up1(new Widget()); // 传统初始化 // C14后推荐使用 std::make_unique std::unique_ptrWidget up2 std::make_uniqueWidget(); up1-doSomething(); // 像普通指针一样使用 - 和 * // std::unique_ptrWidget up3 up1; // 错误不能复制 std::unique_ptrWidget up3 std::move(up1); // 正确所有权转移 // 此时 up1 为空 (nullptr) up3 拥有对象 // 当 up2 和 up3 离开作用域时它们管理的Widget对象会自动被销毁 // 输出两次 Widget destroyed. }std::make_unique的优势异常安全如果new Widget()成功但在构造unique_ptr之前抛出异常会导致内存泄漏。make_unique将分配和构造包装成一个原子操作避免了这个问题。代码简洁无需写两次类型Widget。潜在的性能提升。8.2std::shared_ptr共享所有权的智能指针多个shared_ptr可以共享同一个对象的所有权。它内部使用引用计数。当最后一个shared_ptr被销毁或重置时对象才会被删除。void test_shared() { std::shared_ptrWidget sp1 std::make_sharedWidget(); { std::shared_ptrWidget sp2 sp1; // 复制引用计数1 (现在为2) sp2-doSomething(); // sp2 离开作用域引用计数-1 (现在为1) } // sp1 仍然有效引用计数为1 sp1-doSomething(); // sp1 离开作用域引用计数变为0Widget对象被销毁 }循环引用问题这是shared_ptr的经典陷阱。如果两个对象互相持有对方的shared_ptr它们的引用计数永远无法降到0导致内存泄漏。struct Node { std::shared_ptrNode next; // std::shared_ptrNode prev; // 如果这里也是 shared_ptr就会形成循环引用 std::weak_ptrNode prev; // 正确的做法将其中一个改为 weak_ptr ~Node() { std::cout Node destroyed\n; } }; void test_cyclic_ref() { auto node1 std::make_sharedNode(); auto node2 std::make_sharedNode(); node1-next node2; node2-prev node1; // 如果prev是shared_ptr此处形成循环引用 // 函数结束node1和node2离开作用域但引用计数不为0对象不会被销毁 }8.3std::weak_ptr弱引用指针weak_ptr是为了解决shared_ptr的循环引用问题而设计的。它指向一个由shared_ptr管理的对象但不增加引用计数。它不能直接访问对象必须通过lock()方法尝试提升为一个shared_ptr。void test_weak() { std::shared_ptrWidget sp std::make_sharedWidget(); std::weak_ptrWidget wp sp; // 创建弱引用不增加引用计数 // 使用前需要“锁定” if (auto locked_sp wp.lock()) { // 尝试提升为 shared_ptr locked_sp-doSomething(); // 对象还存在可以安全使用 std::cout Use count: locked_sp.use_count() \n; } else { std::cout Object has been destroyed.\n; } sp.reset(); // 释放对象引用计数变为0对象被销毁 if (auto locked_sp wp.lock()) { // 不会进入这里因为对象已销毁 } else { std::cout Object is gone.\n; // 输出这里 } }智能指针使用准则优先使用unique_ptr默认选择。它开销最小所有权清晰。需要共享所有权时再用shared_ptr。使用weak_ptr来打破循环引用或观察对象。优先使用make_shared和make_unique来创建智能指针。避免将同一个原始指针交给多个智能指针管理这会导致重复释放。不要混合使用智能指针和原始指针管理同一块内存。9. 指针安全与常见陷阱指针能力强大但也伴随着风险。以下是几个最常见的“坑”。9.1 悬空指针指针指向的内存已经被释放但指针本身还未被置空。int *p new int(10); delete p; // 内存释放 // 此时 p 是一个悬空指针 *p 20; // 未定义行为可能崩溃也可能静默破坏其他数据解决方法释放内存后立即将指针置为nullptr。9.2 野指针指针未初始化指向一个随机地址。int *p; // 野指针 *p 10; // 灾难解决方法定义指针时总是初始化哪怕是初始化为nullptr。9.3 内存泄漏分配的内存没有被释放。void leak() { int *p new int[100]; // ... 使用 p ... // 忘记 delete[] p; } // 函数结束p被销毁但它指向的100个int的内存永远无法被访问和释放了。解决方法C中尽可能使用智能指针让RAII帮你管理生命周期。遵循“谁分配谁释放”的原则在代码逻辑清晰的地方配对使用new/delete。使用工具如Valgrind、AddressSanitizer检测内存泄漏。9.4 数组越界访问通过指针访问了分配内存区域之外的空间。int arr[5]; int *p arr; p[5] 10; // 越界访问arr的有效下标是0-4。解决方法始终确保指针运算和下标访问在合法范围内。对于动态数组自己记录大小。9.5 类型不匹配的解引用float f 3.14; int *p (int*)f; // 危险的类型转换 printf(%d\n, *p); // 输出的不是3而是f的二进制位解释成的整数解决方法避免使用C风格强制转换。如果必须进行类型转换使用C的static_cast、reinterpret_cast等并清楚知道自己在做什么。10. 指针在特定场景下的应用10.1 单片机/嵌入式开发在资源受限的嵌入式系统中指针是直接操作硬件寄存器的必备工具。寄存器通常被映射到特定的内存地址。// 假设一个控制LED的寄存器地址是 0x40021000 #define LED_REGISTER (*(volatile uint32_t *)0x40021000) void turn_on_led() { LED_REGISTER | 0x01; // 通过指针解引用直接设置寄存器的特定位 }这里volatile关键字告诉编译器不要优化对此地址的读写因为它的值可能被硬件改变。10.2 实现数据结构链表、树、图等动态数据结构其核心就是指针。// 单向链表节点 struct ListNode { int data; struct ListNode *next; // 指向下一个节点的指针 }; // 在链表头部插入节点 void insert_at_head(struct ListNode **head_ref, int new_data) { struct ListNode* new_node (struct ListNode*)malloc(sizeof(struct ListNode)); new_node-data new_data; new_node-next *head_ref; // 新节点指向原头节点 *head_ref new_node; // 更新头指针 }10.3 函数式编程与回调如前所述函数指针是实现高阶函数、回调机制的基础广泛应用于事件驱动编程、GUI库、算法库如qsort中。指针的学习是一个螺旋上升的过程。开始时你可能会觉得它复杂难懂但一旦你建立了清晰的内存模型理解了地址、值、类型之间的关系它就会变得无比自然。从简单的变量指向到复杂的多级指针和函数指针再到现代C的智能指针每一步都是在增强你对程序的控制力。我的建议是多写、多调试。在调试器中观察指针的值观察它指向的内存内容的变化这是理解指针最直观的方式。不要害怕犯错每一个指针相关的崩溃Segmentation fault都是一次深刻学习的机会。最终你会像熟悉数组和循环一样熟悉指针并能在合适的场景下自信地运用这项强大的工具。