---

【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=000000000061FE1C
p=000000000061FE1C

1.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=000000000061FE1C
p=000000000061FE1C
*p=0000000000000006
k=26

2.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=5

2.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. 如何避免野指针

1. 及时将指针置为 NULL：
   在释放内存后，立即将指针赋值为 NULL。这样可以防止后续访问已经释放的内存。

   int* ptr = (int*)malloc(sizeof(int));
   free(ptr);  // 释放内存
   ptr = NULL;  // 防止野指针
   

2. 初始化指针：
   在声明指针时，尽量将其初始化为 NULL，这样即使没有正确赋值，也不会指向一个随机的内存地址。

   int* ptr = NULL;  // 初始化为NULL
   

3. 谨慎使用 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;
}

代码结果：

000000000061FE0C
000000000061FE0C

从上面的结果中我们可以发现：

• 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): 2
arr[1]: 5   <--->   *(pb + 1): 5
arr[2]: 3   <--->   *(pb + 2): 3
arr[3]: 7   <--->   *(pb + 3): 7
arr[4]: 9   <--->   *(pb + 4): 9
arr[5]: 1   <--->   *(pb + 5): 1
arr[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;
}

代码运行结果：

000000000061FE00
000000000061FDE0
000000000061FDC0

2. 指针数组的使用

指针数组是存储一级指针的数组，而一级指针指向的是数组，其使用与二维数组有些相似，但二者并不能完全等同看待。

#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 5
7 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;
}

代码运行结果：

000000000061FE00
000000000061FE00
000000000061FE00000000000061FE20
000000000061FE04
000000000061FE04

上文总结：
&arr 和 arr 在打印时，地址看似相同，但在进行算术运算时产生的结果是不同的。
&arr + 1 指向的是整个数组后的地址，而 arr + 1 和 &arr[0] + 1 都是指向第二个元素 arr[1] 的地址。

结语

在 C 语言中，指针、指针数组和数组指针有着不同的特质与用途：以下是我对这三者的总结，帮助理解它们之间的区别、联系以及如何有效地使用它们。

• 指针：能够直接操控内存地址，借此间接访问和修改数据，可在函数间传递地址以避免大量数据复制，提升效率，同时为动态内存分配提供支持。
• 指针数组：用于集中存储多个同类型数据对象的地址，便于统一管理与操作，能节省内存空间并提高处理效率。
• 数组指针 **专门指向数组，便于对二维或多维数组进行高效操作与访问，简化多维数组元素的处理逻辑。
• 那么我想以上这就是【C 语言指针篇】指针的灵动舞步与内存的神秘疆域：于 C 编程世界中领略指针艺术的奇幻华章的内容了，通过对指针、指针数组和数组指针的学习，使我们可以在编程中更好的解决问题。❤️
  

---

意气风发，漫卷疏狂
学习是成长的阶梯，每一次的积累都将成为未来的助力。我希望通过持续的学习，不断汲取新知识，来改变自己的命运，并将成长的过程记录在我的博客中。
如果我的博客能给您带来启发，如果您喜欢我的博客内容，请不吝点赞、评论和收藏，也欢迎您关注我的博客。
您的支持是我前行的动力。听说点赞会增加自己的运气，希望您每一天都能充满活力！
愿您每一天都快乐，也欢迎您常来我的博客。我叫意疏，希望我们一起成长，共同进步。
我是意疏 下次见！