【C 语言指针篇】指针的灵动舞步与内存的神秘疆域：于 C 编程世界中领略指针艺术的奇幻华章

意疏2024-12-24 12:33

文章目录

  • [【C 语言篇】指针的灵动舞步与内存的神秘疆域：于 C 编程世界中领略指针艺术的奇幻华章](#【C 语言篇】指针的灵动舞步与内存的神秘疆域：于 C 编程世界中领略指针艺术的奇幻华章)
  • 前言
  • 结语

【C 语言篇】指针的灵动舞步与内存的神秘疆域：于 C 编程世界中领略指针艺术的奇幻华章

💬欢迎交流：在学习过程中如果你有任何疑问或想法，欢迎在评论区留言，我们可以共同探讨学习的内容。你的支持是我持续创作的动力！
👍点赞、收藏与推荐：如果你觉得这篇文章对你有所帮助，请不要忘记点赞、收藏，并分享给更多的小伙伴！你们的鼓励是我不断进步的源泉！
🚀推广给更多人：如果你认为这篇文章对你有帮助，欢迎分享给更多对编程感兴趣的朋友，让我们一起进步，共同提升！

前言

指针是 C 语言中强大而精妙的工具，其在内存操作与数据处理方面展现出独特的魅力，广泛应用于各类复杂的编程场景。本篇中，我们将深入且细致地探究指针的基本原理、多样化的类型、灵活多变的运算规则。
本文我们主要来介绍指针:

一 、指针的介绍与使用

1. 指针的介绍

在C语言中，指针是一种变量，其值为另一个变量的地址。通过指针，可以间接访问和操作所指向变量的值，它为C语言提供了强大的底层操作能力和灵活的数据处理方式。指针就是保存地址的变量(可以说指针就是地址)

1.1指针表示
c 复制代码 
int i;
int* p = &i;//(P是一个指针 我们通常会用P表示指针 (point的缩写))

这里的星号表示P是一个指针 指向的是int 然后把i的地址交给了p

c 复制代码 
int* p,q;
int *p,q;

注意了：
上面这两行代码是一样的，都表示p是一个指针指向int。
而q只是一个int型的变量 int q;
我们并不是把加给了int 而是把星号交给了p，所以我们说 p是一个int
如果q也要是指针的话那么也需要加*

c 复制代码 
int *p,*q;
1.2指针变量
  • 变量的值是内存的地址
    • 普通变量的值是实际的值
    • 指针变量的值是具有实际值的变量的地址

作为参数的指针

  • void f(int *p);
  • 在调用时得到某个变量的地址
    • int i =0;f(&i);
  • 在函数里面可以通过这个指针访问外面的这个；
c 复制代码 
#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);
}

这里如果输出的话 就是两个地址值

c 复制代码 
&i=000000000061FE1C
p=000000000061FE1C
1.3空指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。

赋为 NULL 值的指针被称为空指针。

NULL 指针是一个定义在标准库中的值为零的常量

c 复制代码 
#include <stdio.h> 
int main (){
   int  *ptr = NULL; 
   printf("ptr 的地址是 %p\n", ptr  ); 
   return 0;
}

结果：

c 复制代码 
ptr 的地址是 0x0

在大多数的操作系统上，程序不允许访问地址为0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。

如需检查一个空指针，可以使用 if 语句，如下所示：

c 复制代码 
if(ptr)     /* 如果 p 非空，则完成 */
if(!ptr)    /* 如果 p 为空，则完成 */

2. 使用指针

在运用指针的过程中，通常会反复执行以下几个关键步骤：首先是创建一个指针变量，。接着，要把一个普通变量在内存中的地址传递给这个指针，让指针"知道"该去哪个位置找数据。而当我们想要获取指针所指向的那个内存地址中存放的具体值时，就会用到一元运算符"*"。下面的示例就详细展示了这些操作是如何一步步实现的：

  • *是一个单目运算符，用来访问指针的值所表示的地址上的变量
  • 可以做右值也可以做左值
c 复制代码 
int k = *p
*p = k+1

如果我把星号和指针变量联系在一起后 *p的整体其实都可以被看作是一个整数

c 复制代码 
#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);
}

输出结果：

c 复制代码 
&i=000000000061FE1C
p=000000000061FE1C
*p=0000000000000006
k=26
2.1交换两个变量的值

示例代码：

c 复制代码 
#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;
}

代码结果：

c 复制代码 
a=6,b=5
2.2计算输出最小值和最大值

指针的应用场景2

  • 函数返回多个值，某些值就只能通过指针返回
  • 传入的参数实际上是需要保存带回的结果的变量
c 复制代码 
#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];
		}
	}
}

输出结果

c 复制代码 
min=1,max=15

二、野指针的介绍与使用

1. 野指针的介绍

在 C 语言中，野指针（Dangling Pointer）是指一个指针指向一个已经被释放或者没有初始化的内存地址。访问这些内存地址会导致未定义的行为，可能导致程序崩溃、内存泄漏或数据损坏。

2. 野指针的两种常见情况

2.1指向已释放的内存

当通过 free() 释放了动态分配的内存后，指针仍然持有原来内存的地址，但该内存块已不再有效。这时，指针变成了野指针。

c 复制代码 
int* ptr = (int*)malloc(sizeof(int));  // 动态分配内存
*ptr = 10;  // 使用指针
free(ptr);  // 释放内存
// ptr 现在是一个野指针
2.2未初始化的指针

如果一个指针声明时没有被初始化，它的值将是一个随机的地址。这个地址指向的内存可能是无效的，或者是程序不应该访问的内存区域。

c 复制代码 
int* ptr;  // 未初始化的指针，指向一个未知的地址
*ptr = 10;  // 访问未初始化的指针，会引发未定义行为

3. 野指针带来的问题

  • 程序崩溃：访问无效的内存地址会导致程序崩溃，尤其是在访问已释放的内存时。
  • 数据损坏：如果野指针指向的是已经被重新分配的内存区域，程序通过该指针修改数据，可能会损坏原有数据。
  • 内存泄漏 ：如果指针指向的内存已被释放，但没有将指针置为 NULL，程序仍然持有该地址的引用，可能会导致无法再次访问该内存块，造成内存泄漏。

4. 如何避免野指针

  1. 及时将指针置为 NULL ：

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

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

  2. 初始化指针 ：

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

    c 复制代码 
    int* ptr = NULL;  // 初始化为NULL

  3. 谨慎使用 free() ：

    每次释放内存后，确保不再使用该内存区域。并且，只有在内存不再被使用时才调用 free()。

尽量不要使用以下代码

c 复制代码 
#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. 指针和数组的示例

c 复制代码 
#include <stdio.h>

int main()
{
    int arr[] = { 8, 4, 6 };
    int* pb = &arr[0];
    printf("%p\n", arr);
    printf("%p\n", pb);

    return 0;
}

代码结果：

c 复制代码 
000000000061FE0C
000000000061FE0C

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

  • arr是数组名，pb是首元素的地址，而两者的值相等。
    结论：数组名大多数情况都是首元素地址。

3. 指针与数组名[下标]的关系

c 复制代码 
#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;
}

代码运行结果：

c 复制代码 
&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. 遍历数组

  • 下标遍历与指针（地址）±整数遍历
c 复制代码 
#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;
}

代码运行结果：

c 复制代码 
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

从上述代码运行情况可以得知：下标和指针（地址）±整数都能够遍历数组。

  • 下标遍历与数组名±整数遍历
c 复制代码 
#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;
}

从代码运行结果可以得出：下标和数组名±整数都可以遍历数组。

  • 数组首元素地址代替数组名遍历
c 复制代码 
#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. 指针数组的定义

指针数组是一种存储指针的数组。

c 复制代码 
#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;
}

代码运行结果：

c 复制代码 
000000000061FE00
000000000061FDE0
000000000061FDC0

2. 指针数组的使用

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

c 复制代码 
#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;
}

代码运行结果：

c 复制代码 
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)[ ]
c 复制代码 
#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）
    取出数组的地址和数组首元素的地址有什么区别
c 复制代码 
#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试试。

c 复制代码 
#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;
}

代码运行结果：

c 复制代码 
000000000061FE00
000000000061FE00
000000000061FE00

000000000061FE20
000000000061FE04
000000000061FE04

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

结语

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

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

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

相关推荐
向宇it28 分钟前
【从零开始入门unity游戏开发之——C#篇26】C#面向对象动态多态——接口（Interface）、接口里氏替换原则、密封方法（`sealed` ）
java·开发语言·unity·c#·游戏引擎·里氏替换原则
@菜鸟进阶记@31 分钟前
java根据Word模板实现动态填充导出
java·开发语言
卖芒果的潇洒农民33 分钟前
Lecture 6 Isolation & System Call Entry
java·开发语言
AAA.建材批发刘哥34 分钟前
Linux快速入门-Linux文件系统管理
linux·运维·服务器·c语言·学习方法
SomeB1oody1 小时前
【Rust自学】6.1. 定义枚举
开发语言·后端·rust
SomeB1oody1 小时前
【Rust自学】5.3. struct的方法(Method)
开发语言·后端·rust
Kisorge2 小时前
【C语言】指针数组、数组指针、函数指针、指针函数、函数指针数组、回调函数
c语言·开发语言
轻口味3 小时前
命名空间与模块化概述
开发语言·前端·javascript
晓纪同学4 小时前
QT-简单视觉框架代码
开发语言·qt
威桑4 小时前
Qt SizePolicy详解：minimum 与 minimumExpanding 的区别
开发语言·qt·扩张策略
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07构建高效的广告投放系统：应用架构的设计与实现08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10【一文读懂】NTN（非地面网络）技术介绍