1、指针是什么

指针是什么？

指针理解的2个要点：

​ 1、指针是内存中一个最小单元的编号，也就是地址。

​ 2、平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

总结：指针就是地址，口语中说的指针通常是指指针变量。

指针变量

​ 我们可以通过&(取地址操作符)取出变量的内存存储地址，把地址可以存放在一个变量中，这个变量就是指针变量。

#include <stdio.h>
int main()
{
	int a = 10;    //在内存中开辟一块空间
	int* p = &a;   //这里我们对变量a，取出它的地址，可以收用&操作符
	              //a变量占用4个字节的空间，这里将a的4个字节的第一个字节的地址存放在p变量中，p就是指针变量。
	return 0;
}

总结：

指针变量，用来存放地址的变量。（存放在指针中的值都被当作成地址处理）。

那这里有些问题：

• 一个小的单元到底是多大？（1个字节）
• 如何编制？

如何编制？也就是说内存编号/地址是如何产生的呢？

对于一个32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或0）。

那么32根地址线产生的地址就会是：

00000000000000000000000000000000

00000000000000000000000000000001

…

11111111111111111111111111111111

一共会有2的32次方个地址。

每个地址标识一个字节，那我们就可以给2^32Byte == 2^32/1024 == 2^32/1023/1024 == 2^32/1024/1024/1024 ==4GB ，4G的空闲进行编址。同样的方法，那64位机器，如果给64根地址线，也是一样的计算方法。

这里我们就明白：

• 在32位的机器上，地址是32个0或者1组成的二进制序列，那地址就得用4个字节（32bit / 8bit = 4byte）的空间来存储，所以一个指针变量的大小就应该是4个字节。
• 那如果在64位机器上，如果有64个地址线，那一个指针变量大小就是8字节，才能存放一个地址。

总结：

• 指针变量是用来存放地址，地址是唯一标示一块地址空间的。
• 指针的大小在32位平台是4个字节，在64位平台是8个字节。

2、指针和指针类型

这里我们讨论一下：指针的类型。

我们都知道，变量有不同的类型：整型，浮点型等。那指针有没有类型呢？

准确的说：有！

如下代码：

int num = 0;
p = #

要将&num（变量num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？我们给指针变量相应的类型：

char* pa = NULL;
int* pb = NULL;
short* pc = NULL;

下面看段代码来讨论个问题：

#include <stdio.h>
int main()
{
	char* pa = NULL;
	short* pb = NULL;
	int* pc = NULL;
	double* pd = NULL;
	printf("%zu\n", sizeof(pa));   //sizeof()返回的值，最好用%zu来表示。
	printf("%zu\n", sizeof(pb));
	printf("%zu\n", sizeof(pc));
	printf("%zu\n", sizeof(pd));
	return 0;
}

输出：由于我这里是x64环境，所以显示都是8，x86会显示都是4

那么现在来考虑个问题：既然char类型的指针，和int类型的指针，和short类型的指针，和double类型的指针占用内存空间都是一样的，那为什么需要分类型呢？怎么不直接声明个统一的类型呢？

其实每一个指针类型是有意义。

指针类型第一个意义：

结论：指针类型决定了指针在被解引用的时候访问几个字节，如果是int*的指针，解引用访问4个字节，如果是char*的指针，解引用访问1个字节，其它的也是同样道理。

举个例子：我们声明个int类型的a变量，然后取a地址&a，用char*去接收，那这样我们在解引用*pa时，只能访问a变量的第一个字节里面的值，因为a是类型的变量，占用4个字节，但是这时只能访问第一个地址里面的值。

#include <stdio.h>
int main()
{
	int a = 0;
	char* pa = &a;
	*pa = 1;
	return 0;
}

指针类型第二个意义：

结论二：指针的类型决定了指针+1或者指针-1操作的时候，跳过几个字节，也就是决定了指针的步长。

举个例子：我们用char*和int*来存储同一个变量的内存地址，值应该是一样的

#include <stdio.h>
int main()
{
	int a = 0;
	int* pa = &a;
	char* pc = &a;
	printf("pa = %p\n", pa);
	printf("pc = %p\n", pc);
	return 0; 
}

输出：

但是现在我输出pa+1和pc+1，这个时候就会出现差异：

#include <stdio.h>
int main()
{
	int a = 0;
	int* pa = &a;
	char* pc = &a;
	printf("pa = %p\n", pa);
	printf("pa = %p\n", pa+1);
	printf("--------------------------------\n");
	printf("pc = %p\n", pc);
	printf("pc = %p\n", pc+1);
	return 0; 
}

输出：

那这个时候，会发现当打印pa+1，pc+1时，由于pa指针是int类型的，所以在pa+1之后整体内存是直接加了4个字节的过程。而由于pc指针是char类型的，所以在pa+1之后整体内存是直接加了1个字节的过程。

这就是指针类型的第二个意义。

这样的效果有什么实际的作用吗？肯定有！

比如：当我们想解引用访问一个变量时，我们可以选择跳过访问时就可以使用int类型的指针，选择一个一个的访问时就可以使用char类型的指针。这个需要看个人需求。

指针类型意义补充：int类型的和folat类型的用的效果一样吗？

先看如下代码：

#include <stdio.h>
int main()
{
	int a = 0;
	int* pa = &a;     //pa解引用访问4个字节，pa+1也是跳过4个字节
	float* pf = &a;   //pf解引用访问4个字节，pf+1也是跳过4个字节
	return 0; 
}

我们知道int类型的占用4个字节，folat也是占用4个字节。

所以pa解引用访问4个字节，pa+1也是跳过4个字节，同样，pf解引用访问4个字节，pf+1也是跳过4个字节。

其实pa和pl的权限是一样的，但是最终的效果却是不一样的。

所以pa和pl也不能混用。

总结

不同类型之间的指针，解引用就两条意义：

• 解引用访问时访问不同的字节
• pi+1或者pi-1跳过不同的字节。

3、野指针

概念：野指针就是指针指向的位置时不可知的（随机的，不正确的，没有明确限制的）

3.1、野指针成因

1、指针未初始化

#include <stdio.h>
int main()
{
	int* p;    //指针未初始化，因为着没有明确的指向
	*p = 10;   //非法访问内存，这里的p就是野指针
	return 0; 
}

2、指针越界访问

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = arr;   //arr=&a[0]
	int  i = 0;
	for (i = 0; i <= 10; i++)
	{
		*p = i;          //当i=10时，属于越界访问，当指针指向的范围超出数组arr的范围时，p就是野指针
		p++;
	}
	return 0; 
}

3、指针指向的空间释放

这里放在动态内存开辟的时候讲解。

3.2、如何避免野指针

1、指针初始化

2、小心指针越界

3、指针指向空间释放即使置NULL

4、避免返回局部变量的地址

5、指针使用之前检查有效性

int* p1 = NULL;       //指针初始化为空值

4、指针运算

• 指针+/-整数
• 指针 - 指针
• 指针的关系运算

4.1、指针+/-整数

看如下代码：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		*p=1;
		p++;
	}
	return 0;
}

扩展：

#include <stdio.h>
int main()
{
	#define N_VALUES 5
	float values[N_VALUES];     //创建个float类型的数组
	float* vp;
	for (vp = &values[0]; vp < &values[N_VALUES];)
	{
		//这个相当于两步操作：1、*vp = 0     2、vp++
		*vp++;        
	}
	return 0;
}

4.2、指针-指针

看如下代码：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d", &arr[9] - &arr[0]);
	return 0;
}

输出：

那如果是&arr[0] - &arr[9]呢？

答案是-9。

结论：|指针 - 指针|（绝对值）得到的是指针和指针之间元素个数。

4.3、指针的关系运算

5、指针和数组

数组：一组相同类型元素的集合。

指针变量：是一个变量，存放的是一个地址。

数组是数组，指针是指针。本质上二者没有联系，但是我们通过指针来操作数组。

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	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;
}	

输出：

补充：arr[i]就相当于*(arr+i)。这是本质。

6、二级指针

先看段代码：

#include <stdio.h>
int main()
{
	int a = 0;
	int* pa = &a;    //pa是一个指针变量，一级指针变量
	int* * ppa = &pa;   //ppa是一个二级指针变量
    **ppa = 20;
	printf("%d", a);
	return 0;
}	

输出：

pa经过一次解引用就可以访问到a，称为一级指针变量。

ppa经过两次解引用才可以访问到a，称为二级指针变量。

二级指针变量是用来存放一级指针变量的地址。

然后**ppa相当于解两次引用，所以可以访问到a。

下面来分解一下：

7、指针数组

指针数组是指针还是数组？

指针数组：存放指针的数组就是指针数组。

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int* parr[10] = { &a,&b,&c };   //paar就是指针数组
	return 0;
}	

然后遍历指针数组进行读取a，b，c的值：

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int* parr[10] = { &a,&b,&c };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
        //paar[i]是找到指针数组中的每一个元素，也就是&a,&b,&c，然后在*解引用，即可访问到指定的变量
		printf("%d ", *(parr[i]));
	}
	return 0;
}	

输出：

7.1、用指针数组模拟二维数组

如下代码：

#include <stdio.h>
int main()
{
	int arr1[4] = { 1,2,3,4 };
	int arr2[4] = { 2,3,4,5 };
	int arr3[4] = { 3,4,5,6 };
	int* parr[3] = { arr1,arr2,arr3 }; 
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
        //parr[i]相当于遍历出：arr[0],arr[1],arr[2]，然后parr[i][j]相当于遍历出：arr[0][1]...
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}	

输出：

图解上述：