【C语言学习】深入理解指针（1）

embrace99

已于 2023-08-25 20:29:58 修改

阅读量96

点赞数

分类专栏： C语言学习文章标签： c语言学习开发语言算法 c# 数据库学习方法

于 2023-08-17 23:34:15 首次发布

本文链接：https://blog.csdn.net/embrace99/article/details/132304263

版权

C语言学习专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1. 内存和地址

1.1 内存

在讲解内存之前，我们先了解一个生活中的案例：
假设有一栋宿舍楼，把你放在楼里，楼上有100个房间，但是房间没有编号。有一天，你的朋友来找你玩，如果想找到你，就得挨个房子去找，这样效率很低，但是我们如果根据楼层和楼层的房间的情况，给每个房间编上号，如：
一楼：101，102，103…
二楼：201，202，203…
三楼：…

有了房间号，你的朋友就可以快速的找房间，找到你。

如果把上面的例子类比到计算机中，情况又将会是怎样呢？
我们都知道计算机中的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中。

早期的计算机内存很小，大概在几百兆左右。随着计算机技术的不断发展，现如今已经达到32G、64G甚至更大的规模，那这些庞大的空间又该如何进行高效的管理呢？
其实不管内存空间有多大，都是将其划分为⼀个个的内存单元，每个内存单元的大小取1个字节。
说到字节，我们再来回顾一下计算机中常见的单位：
⼀个比特位可以存储⼀个2进制位的0或1

bit - ⽐特位     
byte - 字节		1byte = 8bit
KB				1kB = 1024 byte
MB				1MB = 1024 KB
GB				1GB = 1024 MB
TB				1TB = 1024 GB
PB				1PB = 1024 TB

其中，每个内存单元，相当于一个学生宿舍，一个字节空间里面能放8个比特位，就好比住的8人间，每个人就是一个比特位。
每个内存单元也都有一个编号（这个编号就相当于宿舍房间的门牌号），有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间。

生活中我们把门牌号叫地址，而在计算机中我们把内存单元的编号也称为地址。但是在C语⾔中给地址起了一个新的名字：指针。
所以我们可以理解为：
内存单元的编号 == 地址 == 指针

1.2 如何理解编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址(就如同宿舍很多，需要给宿舍编号⼀样)。
计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计来完成。
钢琴、吉他上面没有写明“都瑞咪发嗦啦”这样的信息，但演奏者照样能够准确找到每⼀个琴弦的每⼀个位置，这是为何？因为制造商已经在乐器硬件层面上设计好了，并且所有的演奏者都知道。本质上就是⼀种约定出来的共识！
硬件编址也是如此，首先，必须理解，计算机内有很多的硬件单元，而硬件单元是要互相协同工作的。所谓的协同，至少相互之间要能够进行数据传递。但是硬件与硬件之间又是互相独立的，那么该如何通信呢?答案很简单，就是用 “线” 连起来。而CPU和内存之间也是有大量数据交互的，所
以，两者必须也用线连起来。不过，我们今天只关心⼀组线，叫地址总线。

我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表示0,1（电脉冲有无），那么⼀根线，就能表示2种含义，2根线就能表示4种含义。依此类推，32根地址线，就能表示 $2^{32}$ 种含义，每⼀种含义都代表⼀个地址。地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

2. 指针变量和地址

2.1 取地址操作符（&）

理解了内存和地址的关系，我们再回到C语⾔，在C语⾔中创建变量其实就是向内存申请空间！

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
	
int main()
{
	int a = 10;//变量创建的本质：在内存上开辟空间
	//要向内存申请个字节的空间，存放数据10
	//10 ---> a
	//0000 0000 0000 0000 0000 0000 0000 1010
	//0x   00   00   00   0a
	//
	//%a  &---取地址操作符
	printf("%p\n", &a);
	
	return 0;
}

调试起来：

整型变量a，在内存中申请4个字节，用于存放整数10，每个字节都有地址，上图中4个字节的地址分别是：

0x006FFC0C
0x006FFC0D
0x006FFC0E
0x006FFC0F

&a取出的是a所占4个字节中第一个字节的地址（地址较小的那个字节的地址）来打印，即：0x006FFC0C 。
虽然整型变量占用4个字节，但我们只要知道了第⼀个字节地址，顺藤摸瓜访问到4个字节的数据也是可行的。

2.2 指针变量和解引用操作符（*）

2.2.1 指针变量

我们通过取地址操作符(&)拿到的地址是⼀个数值，比如：0x006FFD70，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址值存放在哪里呢？答案是：指针变量中。
例如：

#include <stdio.h>
int main()
{
 	int a = 10;
 	int* ptr = &a;//取出a的地址并存储到指针变量ptr中
 	//编号==地址==指针
 	return 0;
}

那么int*又该如何理解呢？
ptr左边写的是 int*，* 是在说明ptr是指针变量，而前面的 int 是在说明ptr指向的是整型（int）类型的对象。

类似的，如果有⼀个char类型的变量ch，那ch的地址就应该放在char*类型的指针变量中。

char* ptr = &ch;

2.2.2 解引用操作符

我们将地址保存起来，未来是要使用的，那应该怎么使用呢？
在现实生活中，我们使用地址去找到⼀个房间，在房间里可以拿或者存放物品。
C语言中也是⼀样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，而在这之前我们必须要学习⼀个操作符叫解引用操作符（*）。
例如：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
	
int main()
{
	int n = 0x11223344;
	int* p = &n;
	*p = 0;
	return 0;
}

代码调试起来：

0x11223344是16进制数，因为每一位是4个二进制数，所以能存下。我们通过调试，发现内存确实已经存入n。

然后，我们把n的地址取出来放到p中，然后解地址*p = 0（ *p 的意思就是通过n中存放的地址，找到指向的空间，*p其实就是n变量了）。通过取地址n，发现n里面存储的数据全部变为了0。

有小伙伴肯定会问：如果这里的目的就是把n改成0的话，写成 n = 0 不就完了吗，为啥非要使用指针呢？
其实这里是把n的修改交给了p来操作，这样对n的修改，就多了⼀种的途径，写代码就会更加灵活。可能小伙伴们有些懵，没关系，后面就慢慢理解了。

2.3 指针变量的大小

在讲解指针变量大小之前，我们先看下面一段代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{

	int num = 10;
	int* p = &num;

	char ch = 'w';
	char* pc = &ch;

	printf("%u\n", sizeof(p));
	printf("%u\n", sizeof(pc));
	return 0;
}

运行结果：

我们发现两种类型的指针变量大小都是4个字节，这是为什么呢？
首先我们要明白指针是用来干什么的？指针是为了存放地址，而地址的大小取决于存储一个地址需要多大的空间。
地址是由地址总线产生的，32位的机器有32根地址线，地址上传输过来的电信号转换成数字信号后，得到的32个0/1组成的序列就是地址。地址都是32个0/1组成的二进制序列的话，那么存放这个地址所需要的空间大小是4个字节。所以指针变量的大小都是4个字节。
同理64位机器，假设有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要8个字节的空间，指针变的大小就是8个字节。

同理，各种类型指针的大小：都是4或者8

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//指针变量的⼤⼩取决于地址的⼤⼩
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
int main()
{
	printf("%u\n", sizeof(char *));
	printf("%u\n", sizeof(short *));
	printf("%u\n", sizeof(int *));
	printf("%u\n", sizeof(double *));
	return 0;
}

x86环境运行结果：

x64环境运行结果：

总结：
1.32位平台下地址是32个bit位，指针变量大小是4个字节
2.64位平台下地址是64个bit位，指针变量大小是8个字节
3.指针变量的大小和类型是无关的

3. 指针变量类型的意义

指针变量的大小和类型无关，只要是指针变量，在同⼀个平台下，大小都是⼀样的，为什么还要有各种各样的指针类型呢？
其实指针类型是有特殊意义的，我们接下来继续学习。

3.1 指针的解引用

0x11223344是16进制数，因为每一位是4个二进制数，所以能存下。我们通过调试，内存确实发现已经存入n中。
我们把n的地址取出来放到p中，然后解地址*p = 0。通过取地址n，发现n里面存储的数据全部变为了0。
现在我们把int* 改为char*，那还能放下n的地址吗？答案是肯定的。

但是我们通过调试发现，只有第一项只有第一个字节变为了0。
由此，我们可以得出结论：
1.指针类型是有意义的；
2.指针类型决定了指针在解引用时的权限，也就是一次解引用，访问几个字节，int*类型的指针在解引用时访问4个字节，char*类型的指针在解引用时访问1个字节。

3.2 指针 + - 整数

先看⼀段代码，调试观察地址的变化：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int n = 0x11223344;
	int* p = &n;
	char* pc = &n;
	
	printf("p    = %p\n", p);
	printf("p+1  = %p\n", p + 1);
	printf("pc   = %p\n", pc);
	printf("pc+1 = %p\n", pc + 1);
	return 0;
}

运行结果：

我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。
这就是指针变量的类型差异带来的变化。
总结：
1.指针类型是有意义的；
2.指针类型决定了指针在+1/-1操作的时候，一次跳过几个字节（指针的步长）
如果把改为n的话，跳过的是n个指向值。

4. const修饰指针

先看下面一段代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	const int n = 100;
	int* p = &n;
	*p = 10;
	printf("%d\n", n);
	return 0;
}

运行结果：

通过代码我们发现，虽然const修饰变量n后，我们无法直接修改，但是当我们把变量的地址取出来，通过解引用操作*p=10，我们依然能够修改n的值。
这就好比我们发现门关了，就从窗户爬进去，这种爬窗户的行为显然是我们所不能接受的。
这显然也不合理，我们应该限制p也不能修改。要做到这种效果，需要我们用const来修饰指针。

4.1 const放在*的左边

4.2 const放在*的右边

通过以上两个例子，我们可以得出结论：
1.const如果放在*的左边，限制的是指针指向的内容，意思是不能通过指针来修改指针指向的内容。但是指针变量本身是可以修改的。
2.const如果放在*的右边，限制的是指针变量本身，意思是不能修改指针变量的指向，但是可以修改指针指向的内容。
在这里给各位小伙伴举一个生动形象的例子：
我们假设有一个女孩p，两个男孩分别叫m和n，男孩m兜里有100块钱，男孩n的兜里有10块钱。p是n的女朋友，有一天，他们两人一起逛街。p看到一摊位上卖凉皮，于是就和n说，你能请我吃一碗凉皮吗？凉皮10元一碗，如果n答应了，那兜里的10块钱就被女孩花光了（*p=0）。这时候，n不同意（const int *p = &n），于是女孩就没法花男孩n的钱。这时候，p心里气不过，于是找到男孩m（p = &m）请她吃凉皮。男孩n心想这样不行，于是就找到p说，你不能换男朋友（int* const p = &n）。

5. 指针的运算

指针的基本运算有三种，分别是：
• 指针+ - 整数
• 指针-指针
• 指针的关系运算

5.1 指针+ -整数

因为数组在内存中是连续存放的，所以只要知道了第⼀个元素的地址，顺藤摸瓜就能找到后面的所有元素。

int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int *p = &arr[0];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i<sz; i++)
	{
		printf("%d ", *(p + i));//p+i 这⾥就是指针+整数
	}
	return 0;
}

运行结果：

整个实现过程如下图所示：

5.2 指针 - 指针

前提条件：两个指针指向同一块空间。
指针 - 指针得到的是两个指针之间元素的个数。
例如：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int my_strlen(char* str)
{
	char* start = str;
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

运行结果：

5.3 指针的关系运算

指针的关系运算其实就是地址比较大小。
前面我们通过循环的方式实现对数组的访问，而通过比较指针的大小，我们也可以实现对数组的访问：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//int* p=&arr[0];
	int* p = arr;//数组名就是首元素的地址
	while (p < arr + sz)//指针大小的比较
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

运行结果：

6. 野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）。
我们可以把野指针看成是一条野狗，这是一种危险的信号。

6.1 野指针成因

那野指针是怎么产生的呢？
一般来说，产生野指针原因有3种：1. 指针未初始化；2. 指针越界访问；3. 指针指向的空间释放

6.1.1 指针未初始化

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int *p;//局部变量指针未初始化，默认为随机值
	*p = 20;
	return 0;
}

运行结果：

6.1.2 指针越界访问

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int arr[10] = { 0 };
	int *p = &arr[0];
	int i = 0;
	for (i = 0; i <= 11; i++)
	{
		//当指针指向的范围超出数组arr的范围时，p就是野指针
		*(p++) = i;
	}
	return 0;
}

运行结果：

调试起来以后：
在这里插入图片描述

6.1.3 指针指向的空间释放

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int* test()
{
	int n = 100;
	return &n;
}

int main()
{
	int* p = test();
	printf("%d\n", *p);
	return 0;

运行结果：

test函数返回之后，确实把n的地址带回来放到p里边去了。但是有一个现象需要我们注意，这个n是个局部变量，进入函数创建，出函数就销毁了。也即是进入函数后存放n的4个字节拿到了，出函数就还给操作系统了，但是p中还存放着这个地址。如果通过解引用操作给它赋值20，将20这个值放到n里面去，这样就非常危险。

6.2 如何规避野指针

既然知道了野指针的成因，那么 “对症下药” 就能找到规避它们的方法。

6.2.1 指针初始化

如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL。
NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是无法使用的，读写该地址
会报错。
初始化如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int num = 10;
	int*p1 = &num;
	int*p2 = NULL;

	return 0;
}

6.2.2 小心指针越界

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* p = arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *p);
		p++;
	}
	//在这里继续使用p的话，p就成野指针了
	p = NULL;

	p = arr;
	if (p != NULL)
	{
		//...
	}
	return 0;
}

⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是
越界访问。要解决越界访问，只能小伙伴们自己去解决，多敲代码。

6.2.3 指针变量不再使用时，及时置NULL，指针使用之前检查有效性

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使用这个指针访问空间的
时候，我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，同时使用指针之前可以判断指针是否为NULL。
前面我们把野指针想象成野狗，野狗放任不管是非常危险的，所以我们可以找⼀棵树把野狗拴起来，就相对安全了，给指针变量及时赋值为NULL，其实就类似把野狗栓前来，就是把野指针暂时管理起起来。
不过野狗即使拴起来我们也要绕着走，不能去挑逗野狗，有点危险；对于指针也是，在使用之前，我们也要判断是否为NULL，看看是不是被拴起来起来的野狗**，**如果是不能直接使用，如果不是我们再去使用。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 67, 7, 8, 9, 10 };
	int *p = &arr[0];
	for (i = 0; i<10; i++)
	{
		*(p++) = i;
	}
	//此时p已经越界了，可以把p置为NULL
	p = NULL;
	//下次使⽤的时候，判断p不为NULL的时候再使⽤
	//...
	p = &arr[0];//重新让p获得地址
	if (p != NULL) //判断
	{
		//...
	}
	return 0;
}

6.2.4 避免返回局部变量地址

返回栈空间的地址问题，很容易造成野指针问题。所以要避免返回局部变量地址。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int* test()
{
	//局部变量
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }';'
	//...
	return arr;
}

int main()
{
	int* p = test();
	//p就是野指针
	return 0;
}

7. assert短言

<assert.h> 头文件定义了宏 assert() ，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>

int main()
{
	int a = 10;
	int* p = NULL;
	assert(p != NULL);
	return 0;
}

运行结果：

如果确实不等于 NULL ，程序继续运行，否则就会终止运行，并且给出报错信息提示。P为空指针，所以p != NULL为假，assert语句开始执行，并把错误的位置打印出来。
assert() 的使用对程序员是非常友好的，使用 assert() 有几个好处：它不仅能自动识别文件和出问题的行号，还有⼀种无需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问题，不需要再做断⾔，就在 #include <assert.h> 语句的前⾯，定义⼀个宏 NDEBUG 。

#define NDEBUG

然后，重新编译程序，编译器就会禁用中所有的 assert() 语句。如果程序又出现问题，可以移
除这条 #define NDBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 assert() 语
句。
但是assert() 也是有缺点的，因为引入了额外的检查，增加了程序的运行时间。
⼀般我们可以在debug中使用，在release版本中选择禁用assert就行，在VS这样的集成开发环境中，在release版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在release版本不影响用户使用时程序的效率。

8. 指针的使用和传址调用

8.1 传址调用

学习指针的目的是使用指针解决问题，那什么问题，非指针不可呢？
例如：写⼀个函数，交换两个整型变量的值
⼀番思考后，我们可能写出这样的代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void Swap1(int x, int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	Swap1(a, b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

运行结果：

我们发现其实没有产生交换的效果，这是为什么呢？
我们将代码调试起来：
在这里插入图片描述
我们发现在main函数内部，创建了a和b，a的地址是0x009efa98，b的地址是0x009efa8c，在调用Swap1函数时，将a和b传递给了Swap1函数，在Swap1函数内部创建了形参x和y接收a和b的值，但是
x的地址是0x009ef9b4，y的地址是0x009ef9b8，x和y确实接收到了a和b的值，不过x的地址和a的地址不⼀样，y的地址和b的地址不⼀样，相当于x和y是独立的空间，那么在Swap1函数内部交换x和y的值，自然不会影响a和b，当Swap1函数用结束后回到main函数，a和b的没法交换。Swap1函数在使用的时候，是把变量本身直接传递给了函数，这种调用函数的方式我们之前在函数的时候就知道了，这
种叫传值调用。
总结：
实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实参。所以Swap1是失败的了。那怎么办呢？
我们现在要解决的就是当调用Swap1函数的时候，Swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使用指针，在main函数中将a和b的地址传递给Swap1函数，Swap函数里边通过地址间接的操作main函数中的a和b就好了。
修改后的代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void Swap2(int*px, int*py)
{
	int tmp = 0;
	tmp = *px;
	*px = *py;
	*py = tmp;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d b=%d\n", a, b);
	Swap2(&a, &b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

运行结果：

我们可以看到实现成Swap2的方式，顺利完成了任务，这⾥调用Swap2函数的时候是将变量的地址传
递给了函数，这种函数调用方式叫：传址调用。

8.2 strlen的模拟实现

说完了传址调用，接下来我们来模拟实现strlen函数。首先我们先了解strlen函数的工作机理：strlen函数从字符串的开头位置依次往后面计数，直到遇到 ‘\0’ 停止，所计算的字符串大小为 ‘\0’ 以前的字符所计算的值。
代码实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int my_strlen(char * str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);
	return 0;
}

运行结果：
<>center

虽然我实现了代码，但是却不够完美，需要我们进一步修改：

//健壮性/鲁棒性
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>

size_t my_strlen(const char * str)
{
	int count = 0;
	assert(str);//确保了指针的有效性
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	size_t len = my_strlen("abcdef");
	printf("%u\n", len);
	return 0;
}