指针的奥秘（一）：指针概念+指针类型+指针运算+野指针

前言：

• 一谈到指针，大家的印象都是非常的难，但是指针对于C语言的学习是至关重要的，有了指针的基础，对于以后学习数据结构有很大的帮助，这是一个承上启下的过程，但是如果指针没有学好的话，学习数据结构是相当吃力地，即便是最简单的顺序表，链表。
• 对于指针的学习，首先是不能畏惧指针，你若害怕一件事，那么迎接你的大概是你最不希望看到的，生活也是如此。所以要有一种迎难而上的精神，要对自己充满信心，抱着一定能学好指针的态度，即便过程艰辛但结局完美，也不辜此行。
• 那么从现在开始，行动起来吧，自信的你才是最完美的自己！

一.内存和地址

1.内存

 在理解指针之前我们需要知道计算机中的内存分配。

• 计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存有8GB/16GB/32GB等，那这些内存空间如何高效的管理呢？
• 其实计算机把内存划分为⼀个个的内存单元，每个内存单元的大小为1个字节。

  将内存比作学校，内存单元就好比⼀个个教室，⼀个字节空间里面能放8个比特位，就好比教室里只能存在8个人，每个人是⼀个比特位。每个内存单元也都有⼀个编号（这个编号就相当于教室的门牌号），有了这个内存单元的编号，CPU就可以快速找到这个内存空间（教室）。生活中我们把门牌号也叫地址，在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起了新的名字叫：指针。

• 所以我们可以理解为：内存单元的编号 == 地址 ==指针

2.编址

• CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址(就如同教室很多，需要给教室编号⼀样)。
• 计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。
• 首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要互相协同工作的。所谓的协同，至少相互之间要能够进行数据传递。但是硬件与硬件之间是互相独立的，那么如何通信呢？答案很简单，用"线"连起来。而CPU和内存之间也是有⼤量的数据交互的，所以，两者必须也用线连起来。不过，我们今天关心⼀组线，叫做地址总线。
• 我们可以简单理解，32位机器有32根地址总线，每根线只有两中状态，表示0,1【电脉冲有无】，⼀根线，能表示2种含义，2根线就能表示4种含义，依次类推。32根地址线，就能表示2 ^ 32种含义，每⼀种含义都代表⼀个地址。所以32位机器共有2 ^ 32个地址。
• 地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。
  

二.指针变量和指针

1.取地址操作符（&）

• 在C语⾔中创建变量其实就是向内存中的栈区申请空间，比如，上述的代码就是创建了整型变量a，向内存中申请4个字节，用于存放整数10，其中每个字节都有地址，上图中4个字节的地址分别是：0x00CFF9C,0x00CFF9D,0x00CFF9E,0x00CFF9F。
• 按照我画图的例子，会打印处理：0x00CFF9C。&a取出的是a所占4个字节中地址较小的字节的地址。虽然整型变量占用4个字节，我们只要知道了第⼀个字节地址，顺藤摸瓜访问到4个字节的数据也是可行的。

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

1.指针变量

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;//取出a的地址并存储到指针变量pa中 
	return 0;
}
1
2
3
4
5
6
7

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

• 指针变量也是⼀种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。
• 我们口头说的指针是指针变量。

2.拆解指针类型

#include <stdio.h>
int main()
{
	int a = 10;
	int * pa = &a;
	return 0;
}
1
2
3
4
5
6
7

• 我们看到pa的类型是 int* ，我们该如何理解指针的类型呢？如图：

3.解引用操作符

#include <stdio.h>
int main()
{
	int a = 100;
	int* pa = &a;
	*pa = 0;
	printf("%d\n", a);//输出0
	return 0;
}
1
2
3
4
5
6
7
8
9

• *pa表示什么意思呢？如图：

• 通过指针来修改，指针所指向的内容，就多了一种途径，体现出代码的灵活，那到底为什么要这样做呢？跟着我将指针学完，你就懂了。

4.指针变量的大小

#include <stdio.h>
//指针变量的大小取决于地址的大小
//32位平台下地址是32个bit位（即4个字节） 
//64位平台下地址是64个bit位（即8个字节） 
int main()
{
	printf("%zd\n", sizeof(char*));
	printf("%zd\n", sizeof(short*));
	printf("%zd\n", sizeof(int*));
	printf("%zd\n", sizeof(double*));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

结论：

• 32位平台下（x86）地址是32个bit位，指针变量大小是4个字节。
• 64位平台下（x64）地址是64个bit位，指针变量大小是8个字节。
• 注意：指针变量的大小和类型是无关的，指针类型的变量，在相同的平台下，大小都是相同的。

三.指针变量的类型和意义

1.指针的解引用

• 以下给出两类代码，理解指针变量类型的意义

代码1：

#include <stdio.h>
int main()
{
	int n = 0x11223344;
 	int *pi = &n; 
 	*pi = 0; 
	return 0;
}
1
2
3
4
5
6
7
8

• 调试我们可以看到，代码1会将n的4个字节全部改为0。

代码1：

#include <stdio.h>
int main()
{
	int n = 0x11223344;
	char* pc = (char*)&n;
	*pc = 0;
	return 0;
}
1
2
3
4
5
6
7
8

• 调试我们可以看到，代码2只是将n的第⼀个字节改为0。

结论：

• 指针的类型决定了，对指针解引用的时候有多大的权限（⼀次能操作（访问）几个字节）。比如： char* 的指针解引用就只能访问⼀个字节，而 int* 的指针的解用就能访问四个字节。这就是代码1与代码2不同的根本原因。

2.指针 ± 整数

• 先来一段代码，观察地址的变化

int main()
{
	int n = 10;
	char* pc = (char*)&n;
	int* pi = &n;
	printf("&n=   %p\n", &n);
	printf("pc=   %p\n", pc);
	printf("pc+1 =%p\n", pc + 1);
	printf("pi=   %p\n", pi);
	printf("pi+1= %p\n", pi + 1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

• 我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。指针+1，其实跳过指针指向的元素的类型的大小（字节数）。指针可以+1，那也可以-1。

结论：

• 指针的类型决定了指针向前或者向后走一步有多大（距离）。

3.void* 指针

• 在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进行指针的±整数和解引用的运算。
• 因为不知道一次访问/跳过多少个字节，但是可以先强制类型转换，再进行指针的±整数和解引用的运算。
• ⼀般 void* 类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。由于这篇文章是初识指针，这一部分放在之后讲解。

四.const修饰指针

1.const修饰变量

• 变量是可以修改的，但是如果我们希望⼀个变量加上一些限制，不能被修改，怎么做呢？这就是const的作用。

#include <stdio.h>
int main()
{
 	int m = 0;
 	m = 20;//m是可以修改的 
 	const int n = 0;
 	n = 20;//n是不能被修改的 
 	return 0;
}
1
2
3
4
5
6
7
8
9

• 上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n进行修改，就不符合语法规则，就报错，致使没法直接修改n。

• 但是如果我们绕过n，使用n的地址，去修改n就能做到了，虽然这样做是在打破语法规则。

int main()
{
 	const int n = 0;
	printf("n = %d\n", n);
 	int* p = &n;
 	*p = 20;
 	printf("n = %d\n", n);
 	return 0;
}
1
2
3
4
5
6
7
8
9

• 我们可以看到这里⼀个确实修改了，但是我们还是要思考⼀下，为什么n要被const修饰呢？就是为了不能被修改，如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让p拿到n的地址也不能修改n，那接下来怎么做呢？于是就有了const修饰指针变量。

2.const修饰指针变量

• ⼀般来讲const修饰指针变量，可以放在 * 的左边，也可以放在 * 的右边，也可以放在两边，意义是不⼀样的。以下为三种可能代码：

int* p//没有const修饰
int const *p//const 放在*的左边做修饰等价于const int *p
int* const p//const 放在*的右边做修饰
int const * const p //const 放在*的左右两边做修饰
1
2
3
4

• 我们看下面代码，来分析具体分析⼀下：

#include <stdio.h>
//代码1 - 测试⽆const修饰的情况 
void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;//ok
	p = &m; //ok

}
//代码2 - 测试const放在*的左边情况 
void test2()
{
	int n = 10;
	int m = 20;
	const int* p = &n;
	*p = 20;//err
	p = &m; //ok
}
//代码3 - 测试const放在*的右边情况 
void test3()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 20; //ok
	p = &m; //err
}
//代码4 - 测试*的左右两边都有const 
void test4()
{
	int n = 10;
	int m = 20;
	int const* const p = &n;
	*p = 20; //err
	p = &m; //err
}

int main()
{
	//测试⽆const修饰的情况 
	test1();
	//测试const放在*的左边情况 
	test2();
	//测试const放在*的右边情况 
	test3();
	//测试*的左右两边都有const 
	test4();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

const修饰指针变量的时候的结论：

• 无const修饰的指针：指针变量本身的内容可变，指针指向的内容，也可以通过指针改变。
• const如果放在 * 的左边：修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。
• const如果放在 * 的右边：修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。
• const如果放在 * 的左右两边：保证了指针变量的内容不能修改，以及保证指针指向的内容不能通过指针来改变。

五.指针运算

1.指针 ± 整数

• 由于数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸瓜能找到后面的所有元素。如何表示呢？如下：

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• p指向整形元素arr[0]，p+1跳过4个字节，也就是1个整形，所以p+1指向整形元素arr[1]。
• p一次访问4个字节，也就是一个整形，得到arr[0]。
• 同理*(p+1)得到arr[1]，按照指针的方法就可以打印数组所有的元素。
• 其实：arr[0]本质就是*(p+0), arr[i]==*(p+i)。
• 还有：数组名arr就是首元素的地址，也就是arr[0]的地址，也可以这么写，arr[0]等价于* (arr+0), arr[i]等价于* (arr+i)。

2.指针 - 指针

• 大指针 - 小指针得到的是指针之间元素的个数，仅限于它们是同一块空间 还有小指针 - 大指针得到的就是负数。例如：

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

• 数组再内存中是连续存放的，且是由低地址向高地址存放的。

3.指针的关系运算

• 指针还能够比较大小，指针本质是地址，地址以16进制显现出来的，所以本质就是比较两个数的大小。

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);
	while (p < arr + sz) //指针的大小比较 
	{
		printf("%d ", *p);//打印数组所有的元素
		p++;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

六.野指针

• 概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的），是非常危险的。

1.野指针成因

1.指针未初始化

//1.指针未初始化
#include <stdio.h>
int main()
{
	int* p;//局部变量指针未初始化，没有明确的指向，默认为随机值 
	*p = 20;//非法访问内存了，p就是野指针
	//随机将p指向的对象改变是非常危险的，这是错误的做法
	return 0;
}
1
2
3
4
5
6
7
8
9

2.指针越界访问

//2.指针越界访问
#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.指针指向的空间释放

//3.返回局部变量的地址（生命周期结束后使用）
int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();
	//p中存着a的地址，a已经还给操作系统了，p不能使用这块空间，p就是野指针
	//但是内存里的这块空间还在，只是不属于当前程序，没有使用着块空间的使用权限
	printf("%d\n", *p);//通过非法的地址，如果这块空间没有被使用（覆盖），还能找到10，但是不属于我们。
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.如何规避野指针

1.指针初始化

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

代码如下：

#include <stdio.h>
int main()
{
	int num = 10;
	int* p1 = &num;
	int* p2 = NULL;
	return 0;
}
1
2
3
4
5
6
7
8

2.小心指针越界

• ⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。导致野指针。

3.避免返回局部变量的地址

• 如造成野指针的第3个例子，不要返回局部变量的地址。

4.指针变量不再使用时置为NULL，指针使用之前检查有效性

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

#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;
	for (i = 0; i < 10; i++)
	{
		*(p++) = i;
	}
	//此时p已经越界了，可以把p置为NULL 
	p = NULL;
	//下次使⽤的时候，判断p不为NULL的时候再使⽤ 
	//...

	p = &arr[0];//重新让p获得地址 
	if (p != NULL) //判断 
	{
		//...
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

七.assert断言

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

assert(p != NULL);
1

• 验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运行，否则就会终止运行，并且给出报错信息提示。

初识指针到这里就结束了，日后还会更新指针的奥秘（2.0）以及（3.0）等等。不要错过了哦。
觉得我写的不错的，可以给个三连哦，您的支持将是我对日后更新最大的动力，感谢啦！！！！