文章目录
【C 语言篇】指针的灵动舞步与内存的神秘疆域：于 C 编程世界中领略指针艺术的奇幻华章前言一 、指针的介绍与使用1. 指针的介绍1.1指针表示1.2指针变量1.3空指针 2. 使用指针2.1交换两个变量的值2.2计算输出最小值和最大值 二、野指针的介绍与使用1. 野指针的介绍2. 野指针的两种常见情况2.1指向已释放的内存2.2未初始化的指针 3. 野指针带来的问题4. 如何避免野指针 三、指针和数组1. 指针与数组的关系2. 指针和数组的示例3. 指针与数组名[下标]的关系4. 遍历数组 四、指针数组1. 指针数组的定义2. 指针数组的使用 五、数组指针1. 指针数组的定义2. 数组的地址和数组首元素的地址的区别 结语
【C 语言篇】指针的灵动舞步与内存的神秘疆域：于 C 编程世界中领略指针艺术的奇幻华章
?欢迎交流：在学习过程中如果你有任何疑问或想法，欢迎在评论区留言，我们可以共同探讨学习的内容。你的支持是我持续创作的动力！
?点赞、收藏与推荐：如果你觉得这篇文章对你有所帮助，请不要忘记点赞、收藏，并分享给更多的小伙伴！你们的鼓励是我不断进步的源泉！
?推广给更多人：如果你认为这篇文章对你有帮助，欢迎分享给更多对编程感兴趣的朋友，让我们一起进步，共同提升！
前言
指针是 C 语言中强大而精妙的工具，其在内存操作与数据处理方面展现出独特的魅力，广泛应用于各类复杂的编程场景。本篇中，我们将深入且细致地探究指针的基本原理、多样化的类型、灵活多变的运算规则。
本文我们主要来介绍指针:
一 、指针的介绍与使用
1. 指针的介绍
在C语言中，指针是一种变量，其值为另一个变量的地址。通过指针，可以间接访问和操作所指向变量的值，它为C语言提供了强大的底层操作能力和灵活的数据处理方式。指针就是保存地址的变量(可以说指针就是地址)
1.1指针表示
int i;int* p = &i;//(P是一个指针 我们通常会用P表示指针 (point的缩写))这里的星号表示P是一个指针 指向的是int 然后把i的地址交给了p
int* p,q;int *p,q;注意了：
上面这两行代码是一样的，都表示p是一个指针指向int。
而q只是一个int型的变量 int q;
我们并不是把加给了int 而是把星号交给了p，所以我们说p是一个int
如果q也要是指针的话那么也需要加*
int *p,*q;1.2指针变量
变量的值是内存的地址 普通变量的值是实际的值指针变量的值是具有实际值的变量的地址作为参数的指针
void f(int *p);在调用时得到某个变量的地址 int i =0;f(&i); 在函数里面可以通过这个指针访问外面的这个；#include <stdio.h>void f(int *p);int main(void){ int i = 6; printf("&i=%p\n",&i); f(&i); return 0;}void f(int *p){printf("p=%p\n",p);}这里如果输出的话 就是两个地址值
&i=000000000061FE1Cp=000000000061FE1C1.3空指针
在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。
赋为 NULL 值的指针被称为空指针。
NULL 指针是一个定义在标准库中的值为零的常量
#include <stdio.h> int main (){ int *ptr = NULL; printf("ptr 的地址是 %p\n", ptr ); return 0;}结果：
ptr 的地址是 0x0在大多数的操作系统上，程序不允许访问地址为0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。
如需检查一个空指针，可以使用 if 语句，如下所示：
if(ptr) /* 如果 p 非空，则完成 */if(!ptr) /* 如果 p 为空，则完成 */2. 使用指针
在运用指针的过程中，通常会反复执行以下几个关键步骤：首先是创建一个指针变量，。接着，要把一个普通变量在内存中的地址传递给这个指针，让指针“知道”该去哪个位置找数据。而当我们想要获取指针所指向的那个内存地址中存放的具体值时，就会用到一元运算符“*”。下面的示例就详细展示了这些操作是如何一步步实现的：
*是一个单目运算符，用来访问指针的值所表示的地址上的变量可以做右值也可以做左值int k = *p*p = k+1如果我把星号和指针变量联系在一起后 *p的整体其实都可以被看作是一个整数
#include <stdio.h>void f(int *p);void g(int k);int main(void){ int i = 6; printf("&i=%p\n",&i); f(&i); g(i); return 0;}void f(int *p){printf("p=%p\n",p);printf("*p=%p\n",*p);*p = 26;}void g(int k){printf("k=%d\n",k);}输出结果：
&i=000000000061FE1Cp=000000000061FE1C*p=0000000000000006k=262.1交换两个变量的值
示例代码：
#include <stdio.h>void swap(int *pa,int *pb);int main(void){int a = 5;int b = 6;swap(&a,&b);printf("a=%d,b=%d\n",a,b);return 0;}void swap(int *pa,int *pb){int t = *pa;*pa = *pb;*pb = t;}代码结果：
a=6,b=52.2计算输出最小值和最大值
指针的应用场景2
函数返回多个值，某些值就只能通过指针返回传入的参数实际上是需要保存带回的结果的变量#include <stdio.h>void minmax(int a[],int len,int *max,int *min);int main(void){ int a[] = {1,2,3,4,5,6,7,8,9,15}; int min,max; minmax(a,sizeof(a)/sizeof(a[0]),&min,&max);//调用 minmax 函数，将数组 a、数组元素的个数（通过 sizeof(a)/sizeof(a[0]) 计算得到），以及 min 和 max 的地址传递过去，以便在函数内修改它们的值 printf("min=%d,max=%d\n",min,max); return 0;}void minmax(int a[],int len,int *min,int *max){ int i; *min = *max=a[0];//将数组的第一个元素赋值给 min 和 max，初始假定数组的最小值和最大值都是第一个元素。 for ( i=1;i<len;i++){ if ( a[i] < *min){ *min = a[i];}if(a[i] >*max){ *max = a[i];}}}输出结果
min=1,max=15二、野指针的介绍与使用
1. 野指针的介绍
在 C 语言中，野指针（Dangling Pointer）是指一个指针指向一个已经被释放或者没有初始化的内存地址。访问这些内存地址会导致未定义的行为，可能导致程序崩溃、内存泄漏或数据损坏。
2. 野指针的两种常见情况
2.1指向已释放的内存
当通过 free() 释放了动态分配的内存后，指针仍然持有原来内存的地址，但该内存块已不再有效。这时，指针变成了野指针。
int* ptr = (int*)malloc(sizeof(int)); // 动态分配内存*ptr = 10; // 使用指针free(ptr); // 释放内存// ptr 现在是一个野指针2.2未初始化的指针
如果一个指针声明时没有被初始化，它的值将是一个随机的地址。这个地址指向的内存可能是无效的，或者是程序不应该访问的内存区域。
int* ptr; // 未初始化的指针，指向一个未知的地址*ptr = 10; // 访问未初始化的指针，会引发未定义行为3. 野指针带来的问题
程序崩溃：访问无效的内存地址会导致程序崩溃，尤其是在访问已释放的内存时。数据损坏：如果野指针指向的是已经被重新分配的内存区域，程序通过该指针修改数据，可能会损坏原有数据。内存泄漏：如果指针指向的内存已被释放，但没有将指针置为NULL，程序仍然持有该地址的引用，可能会导致无法再次访问该内存块，造成内存泄漏。 4. 如何避免野指针
及时将指针置为 NULL：
在释放内存后，立即将指针赋值为 NULL。这样可以防止后续访问已经释放的内存。
int* ptr = (int*)malloc(sizeof(int));free(ptr); // 释放内存ptr = NULL; // 防止野指针初始化指针：
在声明指针时，尽量将其初始化为 NULL，这样即使没有正确赋值，也不会指向一个随机的内存地址。
int* ptr = NULL; // 初始化为NULL谨慎使用 free()：
每次释放内存后，确保不再使用该内存区域。并且，只有在内存不再被使用时才调用 free()。
尽量不要使用以下代码
#include <stdio.h>#include <stdlib.h>int main() { // 动态分配内存 int *ptr = (int *)malloc(sizeof(int)); if (ptr == NULL) { printf("内存分配失败！\n"); return 1; } // 给指针指向的内存区域赋值 *ptr = 42; printf("指针指向的值: %d\n", *ptr); // 释放动态分配的内存 free(ptr); // ptr 仍然指向之前的内存地址，此时 ptr 成为野指针 // 此时访问 *ptr 是未定义行为，应该避免这样做 // printf("指针指向的值: %d\n", *ptr); // 这一行可能导致程序崩溃 return 0;}以下是将上述代码示例进行相似替换后的内容展示（代码功能逻辑基本一致，但可能在具体数值等细节上做了些许变化）：
三、指针和数组
1. 指针与数组的关系
指针和数组在C语言中有非常紧密的关系，主要体现在以下几个方面：
数组名与首元素地址：在大多数情况下，数组名代表的就是数组首元素的地址。例如，对于int arr[] = { 5, 2, 0 };，arr和&arr[0]的值是相等的，它们都指向数组的第一个元素。这意味着可以使用指针来操作数组元素，就好像指针就是数组本身一样。数组的地址和首元素地址的区别：虽然数组名大多数情况下表示首元素地址，但&arr和arr在概念上是有区别的。&arr是整个数组的地址，而arr是首元素的地址。当对它们进行指针运算时，这种区别就会体现出来。例如，对于int arr[10];，&arr + 1的值比arr + 1的值大sizeof(arr)，因为&arr + 1是跳过了整个数组的地址，而arr + 1只是跳过了一个元素的地址。 2. 指针和数组的示例
#include <stdio.h>int main(){ int arr[] = { 8, 4, 6 }; int* pb = &arr[0]; printf("%p\n", arr); printf("%p\n", pb); return 0;}代码结果：
000000000061FE0C000000000061FE0C从上面的结果中我们可以发现：
arr是数组名，pb是首元素的地址，而两者的值相等。结论：数组名大多数情况都是首元素地址。
3. 指针与数组名[下标]的关系
#include <stdio.h>int main(){ int arr[] = { 2, 5, 3, 7, 9, 1, 0 }; int* pb = &arr[0]; for (int i = 0; i < 7; i++) { printf("&arr[%d]: %p <---> pb + %d: %p\n", i, &arr[i], i, pb + i); } return 0;}代码运行结果：
&arr[0]: 000000000061FDF0 <---> pb + 0: 000000000061FDF0&arr[1]: 000000000061FDF4 <---> pb + 1: 000000000061FDF4&arr[2]: 000000000061FDF8 <---> pb + 2: 000000000061FDF8&arr[3]: 000000000061FDFC <---> pb + 3: 000000000061FDFC&arr[4]: 000000000061FE00 <---> pb + 4: 000000000061FE00&arr[5]: 000000000061FE04 <---> pb + 5: 000000000061FE04&arr[6]: 000000000061FE08 <---> pb + 6: 000000000061FE08从上面的代码运行结果可以得出：指针（首元素地址）±整数与&数组名[下标]是相同的。
4. 遍历数组
下标遍历与指针（地址）±整数遍历#include <stdio.h>int main(){ int arr[] = { 2, 5, 3, 7, 9, 1, 0 }; int* pb = &arr[0]; for (int i = 0; i < 7; i++) { printf("arr[%d]: %d <---> *(pb + %d): %d\n", i, arr[i], i, *(pb + i)); } return 0;}代码运行结果：
arr[0]: 2 <---> *(pb + 0): 2arr[1]: 5 <---> *(pb + 1): 5arr[2]: 3 <---> *(pb + 2): 3arr[3]: 7 <---> *(pb + 3): 7arr[4]: 9 <---> *(pb + 4): 9arr[5]: 1 <---> *(pb + 5): 1arr[6]: 0 <---> *(pb + 6): 0从上述代码运行情况可以得知：下标和指针（地址）±整数都能够遍历数组。
下标遍历与数组名±整数遍历#include <stdio.h>int main(){ int arr[] = { 2, 5, 3, 7, 9, 1, 0 }; int* pb = &arr[0]; for (int i = 0; i < 7; i++) { printf("arr[%d]: %d <---> *(arr + %d): %d\n", i, arr[i], i, *(arr + i)); } return 0;}从代码运行结果可以得出：下标和数组名±整数都可以遍历数组。
数组首元素地址代替数组名遍历#include <stdio.h>int main(){ int arr[] = { 2, 5, 3, 7, 9, 1, 0 }; int* pb = &arr[0]; for (int i = 0; i < 7; i++) { printf("pb[%d]: %d <---> *(pb + %d): %d\n", i, pb[i], i, *(pb + i)); } return 0;}从代码运行表现来看，我们可以得出：数组首元素地址可以代替数组名。
结论：
指针（首元素地址）±整数与&数组名[下标]是相同的。下标和指针（首元素地址）±整数都能够遍历数组。下标和数组名±整数都可以遍历数组。数组首元素地址可以代替数组名。arr[i] = *(arr + i) = *(pb + i) = pb[i] 四、指针数组
1. 指针数组的定义
指针数组是一种存储指针的数组。
#include <stdio.h>int main(){ int arr1[] = { 3, 6, 2, 2, 4, 2, 5 }; int arr2[] = { 3, 6, 1, 2, 4, 2, 5 }; int arr3[] = { 7, 5, 3, 1, 1, 1, 1 }; int* pArr[] = { arr1, arr2, arr3 }; int i = 0; for (i = 0; i < 3; i++) { printf("%p\n", pArr[i]); } return 0;}代码运行结果：
000000000061FE00000000000061FDE0000000000061FDC02. 指针数组的使用
指针数组是存储一级指针的数组，而一级指针指向的是数组，其使用与二维数组有些相似，但二者并不能完全等同看待。
#include <stdio.h>int main(){ int arr1[] = { 3, 6, 2, 2, 4, 2, 5 }; int arr2[] = { 3, 6, 1, 2, 4, 2, 5 }; int arr3[] = { 7, 5, 3, 1, 1, 1, 1 }; int* pArr[] = { arr1, arr2, arr3 }; int i = 0; for (i = 0; i < 3; i++) { for (int j = 0; j < 7; j++) { printf("%d ", pArr[i][j]); } printf("\n"); } return 0;}代码运行结果：
3 6 2 2 4 2 5 3 6 1 2 4 2 57 5 3 1 1 1 1五、数组指针
1. 指针数组的定义
数组指针是用来存放数组地址的指针。
数组指针变量如何定义：（假设这里的指针变量是q，数组存放的int类型的变量）
[ ]先结合 ---- （*q）其次它指向的内容是数组 ---- (*q)[ ] ----[ ]中为数组的元素个数最后它指向数组存储变量的类型是什么 ---- int(*q)[ ] #include <stdio.h>int main(){ int arr[8] = { 1, 2, 3, 4, 5, 6, 7, 8 }; int(*q)[8] = &arr; printf("%p", q); return 0;}2. 数组的地址和数组首元素的地址的区别
区别：（&arr与arr）取出数组的地址和数组首元素的地址有什么区别
#include <stdio.h>int main(){ int arr[8] = { 1, 2, 3, 4, 5, 6, 7, 8 }; printf("%p\n", &arr); //打印数组的地址 printf("%p\n", arr); //打印数组首元素的地址 printf("%p\n", &arr[0]); //打印数组首元素的地址 return 0;}这里取出数组的地址和数组首元素的地址看起来好像没什么区别
让它们取出来的地址+1试试。
#include <stdio.h>int main(){ int arr[8] = { 1, 2, 3, 4, 5, 6, 7, 8 }; // 定义并初始化一个包含8个整数的数组 printf("%p\n", &arr); // 打印整个数组的地址，类型为 int (*)[8] printf("%p\n", arr); // 打印数组首元素的地址，类型为 int * printf("%p\n", &arr[0]); // 打印数组首元素的地址，与上面的结果相同 printf("\n"); printf("%p\n", &arr + 1); // 打印整个数组的地址加1，跳过整个数组的大小（8个int），指向下一个内存块 printf("%p\n", arr + 1); // 打印数组首元素的地址加1，指向第二个元素 arr[1] 的地址 printf("%p\n", &arr[0] + 1); // 打印数组首元素的地址加1，指向第二个元素 arr[1] 的地址，与上面的结果相同 return 0;}代码运行结果：
000000000061FE00000000000061FE00000000000061FE00000000000061FE20000000000061FE04000000000061FE04上文总结：
&arr 和 arr 在打印时，地址看似相同，但在进行算术运算时产生的结果是不同的。
&arr + 1 指向的是整个数组后的地址，而 arr + 1 和 &arr[0] + 1 都是指向第二个元素 arr[1] 的地址。
结语
在 C 语言中，指针、指针数组和数组指针有着不同的特质与用途：以下是我对这三者的总结，帮助理解它们之间的区别、联系以及如何有效地使用它们。
指针：能够直接操控内存地址，借此间接访问和修改数据，可在函数间传递地址以避免大量数据复制，提升效率，同时为动态内存分配提供支持。指针数组：用于集中存储多个同类型数据对象的地址，便于统一管理与操作，能节省内存空间并提高处理效率。数组指针 **专门指向数组，便于对二维或多维数组进行高效操作与访问，简化多维数组元素的处理逻辑。那么我想以上这就是【C 语言指针篇】指针的灵动舞步与内存的神秘疆域：于 C 编程世界中领略指针艺术的奇幻华章的内容了，通过对指针、指针数组和数组指针的学习，使我们可以在编程中更好的解决问题。❤️
意气风发，漫卷疏狂
学习是成长的阶梯，每一次的积累都将成为未来的助力。我希望通过持续的学习，不断汲取新知识，来改变自己的命运，并将成长的过程记录在我的博客中。
如果我的博客能给您带来启发，如果您喜欢我的博客内容，请不吝点赞、评论和收藏，也欢迎您关注我的博客。
您的支持是我前行的动力。听说点赞会增加自己的运气，希望您每一天都能充满活力！
愿您每一天都快乐，也欢迎您常来我的博客。我叫意疏，希望我们一起成长，共同进步。
我是意疏 下次见！