深入理解指针【2】--（通俗易懂！！！）

已于 2024-10-02 23:00:32 修改
阅读量1k 收藏 25
点赞数 39
分类专栏： C语言 文章标签： c语言 开发语言 算法 编辑器
于 2024-08-25 10:21:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83009236/article/details/141437664
版权

本章概述

const修饰指针-2

前面，咱们已经讲过了const修饰普通变量（非指针变量）的特点。那么，今天我们来讲讲const修饰指针变量的特点吧。const修饰指针变量很特别，有3种情况要进行解读。

  • const放在* 左边：咱们就用整形指针变量来进行举例。比如，const int *p=&a或者int const *p=&a这两种写法都是在*左边的情况。直接说结论——const 放在 *的左边时，*p是无法执行的（p解操作后，所对应的值是无法修改的），但是p存放的地址可以改变。进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include <stdio.h>
int main()
{
	int a = 10;
	const int* p = &a;   //或者 int const *p=&a
	*p = 30;			//const放在*的左边，*p是无法执行的
	return 0;
}

#define  _CRT_SECURE_NO_WARNINGS	1
#include <stdio.h>
int main()
{
	int a = 10;
	const int* p = &a;   //或者 int const *p=&a
	*p = 30;
	return 0;
}

结果运行图：在这里插入图片描述

  • const放在*右边：放在左边，咱们已经知道了，放在右边，自然而然就能推理出来。比如，int * const p=&a。放在右边就只有这一种写法，可不能这样写：int * p const=&a。它所限制的是——指针变量所存放的地址是无法修改的，但是*p（所指的变量内容是可以改变的）可以执行。进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include <stdio.h>
int main()
{
	int a = 10;
	int c = 20;
	int* const p = &a;    //不可以写成这样：	int* p const = &a;  
	p = &c;           //无法执行
	printf("%p\n", p);
	return 0;
}


#define  _CRT_SECURE_NO_WARNINGS	1
#include <stdio.h>
int main()
{
	int a = 10;
	int c = 20;
	int* const p = &a;   
	p = &c;
	printf("%p\n", p);
	return 0;
}

结果运行图：在这里插入图片描述

  • const放在*的左边和右边：放在 *的左边是限制指针变量的解引用操作，放在 *的右边是限制指针变量的地址改变，那么放在*的左右边呢？——即限制指针变量的解引用操作，又限制指针变量的地址改变。进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include <stdio.h>
int main()
{
	int a = 10;
	int c = 20;
	int const * const p = &a;   
	*p = 30;				//无法执行
	p = &c;					//无法执行
	printf("%d\n", a);
	printf("%p\n", p);
	return 0;
}

结果运行图：在这里插入图片描述

指针运算

指针的基本运算有三种，如下。

  • 指针+ - 整数：就是地址+ - 整数，咱们前面也讲过了 ，地址（指针）+ - 整数，能跨过多少字节取决于指针变量类型。以前我们写过访问数组的代码，比如，printf("%d ",arr[i])
    今天我们用指针进行访问，进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include <stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;		//我们讲过，数组名就是首元素地址，也可以这样写 int* p = &arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p+i));		
	}
	return 0;
}

结果运行图：在这里插入图片描述
代码还可以这样写：

#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;	
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p++));
	}
	return 0;
}

结果运行图：在这里插入图片描述
这里我们稍微讲一下p+i和p++的区别。这俩的本质上没什么区别——都是对数组进行访问。它们的访问方式不同，p+i进行遍历访问，因为解引用操作是对p+i整体进行的，不会改变原有的p的值，每加一个 i 就相当于一个新的p+i的整体分身。但是，p++就不同了，它每次++后，p的值就改变了，就会进行跨越访问——向后移动。如图所示：在这里插入图片描述

  • 指针 - 指针：我们直接说结论：指针-指针（地址-地址）的绝对值就是两个指针之间的元素个数。这里有个大前提：两个指针所指的空间必须是同一块且连续的空间。这很好理解，只有同一个空间，且必须是连续的，咱们才能得到它们之间的元素个数。进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int* pb = &arr[8];
	int c = (int)(pb - p);   //咱们最好强制转换一下类型，省的警告。
	printf("%d\n", c);		//不强制转换类型也可以。
	return 0;
}

结果运行图：在这里插入图片描述
当我们对数组进行指针- 指针运算的时候，可以直接用下标数字直接相减就OK.指针也是有大小指针的——大指针（大地址），小指针（小地址）。当小指针 - 大指针的时候，结果就是负值，但是它的绝对值也是元素个数——所以我们前面讲过了，它们运算的绝对值就是元素个数。进行代码展示：

#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int* pb = &arr[8];
	int c = (int)(p - pb);	//小指针-大指针
	printf("%d\n", c);
	return 0;
}

结果运行图：在这里插入图片描述

  • 指针的关系运算：我们前面也讲过了关系运算符，比如，> ,< ,= ,!=。指针的关系运算无非就是这些关系运算符的操作数变成了指针而已。进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int* pb = &arr[8];
	if (pb > p)   //大指针 > 小指针，所以条件成立
	{
		printf("hhhh");
	}
	return 0;
}

结果运行图：在这里插入图片描述
我们已经学了指针的+ - 运算，指针 - 指针运算和指针关系运算。那么，我们来写个程序运用一下：

// 	写一个程序，用来模仿 sizeof 来计算数组的元素个数

进行代码展示：

#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int* pb = &arr[9];
	int count = 0;
	while (p <= pb)
	{
		count++;
		p++;
	}
	printf("%d\n", count);
	int b = sizeof(arr) / sizeof(arr[0]);
	printf("这是sizeof计算的结果：%d\n", b);
	return 0;
}

结果运行图：在这里插入图片描述
还可以模拟 strlen这个函数，大家可以自行尝试一下。

野指针

概念：就是指针所指的位置是不可知的，或者所指的位置是不属于自己的，就称为野指针。（随机的，不可知的，没有限制的）。接下来，我们讲解野指针的成因。

  • 指针未初始化：指针变量也是变量，咱们以前在变量的那个章节中讲过——局部变量未初始化时，会被系统随机分配数值，全局变量不初始化时，会被默认分配为0。当我们指针变量为全局变量时，会被分配一个地址（是0地址），而且这个地址不会随程序每次调用而改变。指针变量当作局部变量的场景是最多的，所以我们后面所讲指针变量时，就默认都是局部变量。当我们不给指针变量初始化时，就会被系统随机分配地址。这是很危险的，我们知道可以通过指针来更改内存里的数据，这样的话，我们使用指针变量（未初始化）进行更改时，就有可能更改对于我们来讲很重要的数据（事与愿违）。进行代码展示：
    当为全局变量指针时：
#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int* p ；		//全局变量指针
int main()
{
	printf("%p\n", p);
	return 0;
}

结果运行图：在这里插入图片描述
当为局部变量时：

#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
//int a;
//int* p;
int main()
{
	int* p;			//局部变量
	printf("%p\n", p);
	return 0;
}

结果运行图：在这里插入图片描述

  • 指针越界访问：当我们确定好空间后，就只能在这个空间内进行数据的访问，不能访问本空间以外的空间。这个很好理解，我们有多少钱就花多少钱，不能去抢别人的钱。进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i <= sz; i++)
	{
		printf("%d ", *(p + i));   //当访问到下标为10时，就是越界访问
	}
	return 0;
}

结果运行图：在这里插入图片描述

  • 指针访问的空间被释放：先进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();
	printf("%d\n",*p);
	return 0;
}

结果运行图：在这里插入图片描述
当我们在调用函数test()时，操作系统就会给a分配好内存，当我们调用完后，这个内存就后被释放，还给操作系统。 这个知识，咱们在栈帧的创建与销毁中讲过。当test把a的地址传给p时，p就是野指针了。因为，当内存释放的时候，那块内存已经不属于a的内存了，但是这个内存还存在，不会被销毁的（因为内存的地址是硬件设计），我们就没有权限进行访问了（相当于越界访问了）。野指针的成因有很多种，我们在这里举出最常见的原因。我们既然已经知道了野指针的成因，那么我们应该如何规避野指针呢？

  • 指针初始化：当我们知道指针的明确指向时，我们就要进行赋值初始化。当我们没有明确的指向时，我们可以赋予 NULL，NULL是C语言中规定的一个标识符常量，它的值是0（0也是个地址，这个地址我们是不能访问的，一旦访问就会报错）。当一个指针变量被赋值NULL时，它就有个新的名字——空指针。展示它的定义：
 # ifdef __cplusplus		//在C++中，NULL就是0
       # define NULL 0
 # else
       #define NULL ((void *)0)   //在C语言中，NULL是由0强制转换类型而来的。
 # endif

#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
int main()
{
	int a = 10;
	int* p1 = &a;
	int* p2 = NULL;		//p2就是个空指针
	return 0;
}

当我们用完指针后，不想再用时，也对其进行赋值NULL，防止成为野指针。我们来举个例子，以便我们理解NULL。野指针就相当于一条野狗，如果我们不进行管制的话，它就会有伤人的风险，当我们把它拴在一棵上，它救不会乱伤人了，而这棵树就相当于NULL。当一个指针被赋值NULL时，就表明它是个野指针（野狗），我们要绕道走，这就是NULL的作用，而且一但被NULL赋值的指针变量，我们是无法使用的，就像我们明明知道它是条野狗，非要去碰它，肯定会有危险。

  • 避免越界访问：我们使用指针时，要注意不要越界访问，这个没什么好的方法，要注意下就OK了。
  • 避免使用局部变量返回的地址，就像我们上面举例的代码（空间被释放）。

assert断言

是人都会犯错误，我们有时候不注意到野指针，就会报错。那么怎么避免呢？这个时候我们就可以用assert进行一个判断。assert的头文件为：<assert.h> 。assert的使用格式：

//	assert（表达式）
//	表达式的结果为真（表达式成立），程序正常执行
//	表达式的结果为假（表达式不成立），程序就会立即中断，无法正常执行

进行代码展示：

1 #define  _CRT_SECURE_NO_WARNINGS	1
2 #include<stdio.h>
3 #include<assert.h>
4 int main()
5 {
6	int* p = NULL;
7	assert(p != NULL);		//条件不成立，程序无法执行
8	printf("hhh");
9	return 0;
10 }

结果运行图：在这里插入图片描述
当我们修改代码后：

#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
#include<assert.h>
int main()
{
	int a = 10;
	int* p = &a;
	assert(p != NULL);		//表达式为真，程序可以执行
	printf("hhh");
	return 0;
}

结果运行图:在这里插入图片描述
assert对程序员是很友好的，虽然程序走到这里要判断一下（会耽误点运行时间），但可以防止我们出错。一般我们可以在Debug中使用，在Release版本中选择禁用assert就行，在VS这样的集成开发环境中，在Release版本中，直接就是优化掉了。这样在Debug版本写有利于程序员排查问题，在Release版本不影响用户使用时程序的效率。我们不想使用assert时，除了直接删除以外，我们还可以在# include <assert.h>前面加个# define NDEBUG就会禁止assert的使用。进行代码的展示：

#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
#define  NDEBUG		//禁止了assert的使用
#include<assert.h>
int main()
{
	int* p = NULL;
	assert(p != NULL);		//就是个摆设
	printf("hhh");
	return 0;
}

结果运行图：在这里插入图片描述
assert不只是用来判断是否为空指针（空指针只是举个例子），还可以判断别的东西。进行代码展示：

#define  _CRT_SECURE_NO_WARNINGS	1
#include<stdio.h>
#include<assert.h>
int main()
{
	int a = 10;
	assert(a != 20);
	printf("hhh");
	return 0;
}

结果运行图：在这里插入图片描述

指针的使用和传址调用

  • 传值调用：我们先写个程序来感受一下，然后在讲解。
//	我们写一个程序，当我们输入两个整数时，就会交换两个数据。
//	比如，输入 ：a=100 , b=200 。
//		 得到 :	a=200 , b=100 。

进行代码展示：

#define  _CRT_SECURE_NO_WARNINGS	1
#include <stdio.h>
void swap(int x, int y)
{
	int c = 0;
	c = x;
	x = y;
	y = c;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d%d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	swap(a, b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

结果运行图：在这里插入图片描述
我们发现，结果事与愿违。我们创建了swap函数，我们把a ，b的值传给了swap中的x , y了，也就是x就是a ，y就是b。我们进行交换，按理说应该就是交换的，但为什么不是这样呢？这就牵扯到形参与实参的知识了（前面咱们已经讲过了）。实参向形参传的是值，而且形参是单独创立的空间，形参是实参的一个copy版本，形参的改变不会影响到实参。所以，形参里面无论怎样变化，都不会影响到实参，这也就是为什么前后结果一致。

  • 传址调用：传址调用就是传递的是地址。上面我们进行传值是无法进行值的交换，那么我们就进行传址调用，是否能交换呢？进行代码展示：
#define  _CRT_SECURE_NO_WARNINGS	1
#include <stdio.h>
void swap(int* x, int* y)
{
	int c = *x;
	*x = *y;
	*y = c;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d%d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	swap(&a, &b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

结果运行图：在这里插入图片描述
我们可以看出来，传址调用改变了值，因为我们直接调用地址，直接就可以找到对应的值，就可以进行更改（类似远程遥控一样）。

彩蛋时刻！！！

https://www.bilibili.com/video/BV15H4y1F7fc/?spm_id_from=333.337.search-card.all.click&vd_source=7d0d6d43e38f977d947fffdf92c1dfad
在这里插入图片描述
每章一句：想，全是问题。做，才有答案。感谢你能看到这里，点赞+关注+收藏+转发是对我最大的鼓励，咱们下期见！！！

生活很暖很治愈
关注
专栏目录
C语言——指针教程（通俗易懂！）
weixin_45944581的博客
10-19 530
C语言指针教程
单片机C语言入门指导（非常通俗易懂！-综合文档
05-22
本教程将从C语言基础开始讲解，包括变量、数据类型、运算符、流程控制语句（如if-else、switch-case、for、while等）、函数、数组、指针等基本概念。这些是所有C程序设计的基础，对于理解单片机编程至关重要。通过...
[C语言]深入理解指针(1)------这么详细，这么通俗易懂，还不速速码住！！！
2303_80341387的博客
03-18 1098
它确定了CPU可以寻址的范围，我们可以这样理解，在32位机器有32根地址线，在传输要访问的内存地址时，每根地址线可能发出两种信号（0或1），我们有32根地址线，可以在一次操作中传输32个bit位（4个字节）的地址。在C语言中，void* 类型的指针是一个特殊的指针类型，它可以指向任何类型的数据，但在解引用之前，必须将其转换为具体的类型。这两个代码不同的就是我们在定义指针变量时，所定义的指针变量的类型不同，当我们定义指针变量为int类型时，我们通过指针间接访问a时，我们修改a的值时，可以改变4个字节。
由浅入深理解指针-----指针详解（指针初阶）
qq_62655751的博客
10-06 1150
在C语言的学习中，指针是一个让我们非常头疼知识点，指针的知识点多，且易混淆，要想学好指针，首先要知道指针是什么，指针类型的作用是什么，指针的种类有哪些，各种指针怎么用？这些问题在这片文章中你都会得到详细解答哦！提示：以下是本篇文章正文内容，下面案例可供参考。
深入理解 go reflect - 要不要传指针
rubys007的博客
01-13 1031
如果我们需要通过反射对象来修改变量的值，那么我们必须得有办法拿到变量实际存储的内存地址。这种情况下，很多时候都是通过传递指针给方法来实现的。但是对于chanmap和slice或者其他类似的数据结构，它们通过指针来引用实际存储数据的内存，这种数据结构是通过通过传值给方法来实现修改其中的元素的。因为这些数据结构的数据部分可以通过指针的拷贝来修改。但是map和slice有可能会扩容，如果通过反射对象来追加元素，可能导致追加失败。
深入理解指针【1】--（不一样的理解！！！）
2401_83009236的博客
08-22 1432
指针并不难，只是你的方法不对，本博客的指针通俗易懂！！
深入理解指针【3】---（本章内容很重要！）
2401_83009236的博客
08-27 1714
本章内容在指针中起到了中流砥柱的作用，对指针的解读和使用进行了通俗易懂的讲解
通俗易懂C语言--函数指针
Anthony的博客
11-18 610
写博客真是考验自己的耐力，想写点UEFI的东西，但是又得先把基础的C写完，写C挺枯燥的，写完就彻底解放钻研UEFI去了
C语言-深入理解指针（1）
Become Mad的博客
02-27 951
学习到指针部分开始内容可能对有些人不好理解，但是指针又是c语言中不可或缺、十分重要的一个部分。所以我将指针拆接成多个篇章，编写尽量详尽，让读者们更好理解，更容易听懂。
虚函数和纯虚函数--最通俗易懂的讲解
sugarbliss
05-17 7704
上帝是一个程序员，创造了动物(基类)，给予了动物吃饭，睡觉，叫唤等通用功能。(封装) 只指定了平均睡觉八小时(虚函数)，其中没有指定具体的吃饭，叫唤的行为。(纯虚函数) 然后细分一下，动物有猫狗羊和人。(继承) 人类明确它们物种的时候(明确类型的派生类指针) 猫吃鱼 狗吃肉 羊吃草 猫喵喵 狗汪汪 羊咩咩(多态 同名覆盖) 一切都如此顺理成章。 突然人发现一只动物！ 这只是什么呢？诶？这货不知道是啥！只能用"动物"来称呼他！(基类指针指向子类对象) 当没有虚函数的时候，人类发现这只动物不会叫也不.
algorithm-base:为刚刷题没多久的同学准备的算法基地，没有最细只有更细，用动画将晦涩难懂的算法说的通俗易懂！
03-17
"algorithm-base"项目旨在为初涉算法刷题的同学提供一个详尽的学习资源，通过生动的动画形式，将复杂的算法原理讲解得通俗易懂。 在"algorithm-base"中，你可以期待以下几个方面的学习内容： 1. **基础知识**：从...
通俗易懂的c指针教程
06-14
本教程旨在提供一个通俗易懂的视角，帮助初学者快速掌握C语言指针的基本概念和实际应用。 **一、指针的基本概念** 1. **什么是指针？** 指针在C语言中是一个变量，存储的是另一个变量的地址。这个地址指向内存中...
SDH原理-通俗易懂版
11-12
SDH（Synchronous Digital Hierarchy，同步数字体系）是...以上内容涵盖了SDH的基础知识，从原理到实际应用，为初学者提供了全面的理解。通过深入学习，读者将能掌握SDH技术的核心要点，为从事相关工作打下坚实基础。
C. Add Zeros（cf982）
最新发布
m0_74310050的博客
10-30 685
题意：给定长度为n的数组a，可以进行以下操作：选择一个位置i，并且ai=a的长度+1-i；在a的末尾添加i-1个零，多次执行操作后数组a的最大可能长度是多少。分析：ai=|a|-i+1，所以|a|=ai+i-1，用map记录每个点都需要多少长度才可以变,记得vis开大点不然放不下。
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 1205
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 392
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
Go offline for a while
10-30 960
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 291
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
姚云飞《彻底搞定C指针》详解：深入理解与实践指南
作者姚云飞以通俗易懂的方式深入浅出地讲解了指针的原理和机制，包括变量内存实质、指针的定义、数组名与指针的关系、constint*pi与int*constpi的区别、函数参数的传递方式以及指向另一指针的指针等核心知识点。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值