🕺作者：启明星使

🎃专栏：《数据库》《C语言》《数据结构》

🏇分享喜欢的一句话：去发光，而不是等待被照亮​

目录

1. 指针是什么

内存

指针变量

总结：

外：

2. 指针和指针类型

3. 野指针

3.1 野指针成因

3.2 如何规避野指针

4. 指针运算

4.1 指针加减整数

4.2 指针减指针

4.3 指针的关系运算

5. 指针和数组

6. 二级指针

7. 指针数组

1. 指针是什么

指针是什么？ 指针理解的2个要点：

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

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

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

内存

​

指针变量

我们可以通过&（取地址操作符）取出变量的内存其实地址

把地址可以存放到一个变量中，这个变量就是指针变量

​

#include 
int main()
{int a = 10;//在内存中开辟一块空间int *pa = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。printf("%p\n", &a);printf("%p\n", pa);*pa = 20;//* - 解引用操作printf("%d\n", a);return 0;
}

​

我们打开调试，监视pa和查看a的内存地址，发现是一样的

​

说明此时pa这个指针变量已经存储了a的第一个字节的地址

总结：

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

那这里的问题是： 一个小的单元到底是多大？（1个字节） 如何编址？

经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。

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

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

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000001

...

11111111 11111111 11111111 11111111

这里就有2的32次方个地址。 每个地址标识一个字节，那我们就可以给 （2^32Byte == 2^32/1024KB == 2^32/1024/1024MB==2^32/1024/1024/1024GB == 4GB） 4G的空间进行编址。 同样的方法，那64位机器，如果给64根地址线，那能编址8G的空间。 这里我们就明白：

• 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。

• 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

外：

• 指针变量是用来存放地址的，地址是唯一标示一个内存单元的。

• 指针的大小在32位平台是4个字节，在64位平台是8个字节。

2. 指针和指针类型

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

我们都知道，变量有不同的类型，整形，浮点型等。

那指针有没有类型呢？ 准确的说：有的。

当有这样的代码：

int num = 10;
p = #

要将&num（num的地址）保存到p中

我们知道p就是一个指针变量，那它的类型是怎样的呢？

我们给指针变量相应的类型。

char  *pc = NULL;
int  *pi = NULL;
short *ps = NULL;
long  *pl = NULL;
float *pf = NULL;
double *pd = NULL;

这里可以看到，指针的定义方式是： type + * 。

其实： char* 类型的指针是为了存放 char 类型变量的地址。

short* 类型的指针是为了存放 short 类型变量的地址。

int* 类型的指针是为了存放 int 类型变量的地址。

在这里我们实际测试一下

int main()
{int a = 0x11223344;char* pc = &a;*pc = 0;
​return 0;
}

给这样一串代码调试

一开始查看a的内存地址

​

然后下一步到

char*pc=&a

定义char类型的指针pc来保存a的地址

*pc=0过后它变成了这样

​ 

这是为什么呢？

这是因为char类型的指针一次只访问一个字节，同时把0赋给了它

那指针类型的意义是什么？

指针的不同类型，其实提供了不同的视角去观看和访问内存

指针的解引用

• 指针类型决定了，指针进行解引用操作的时候一次性访问几个字节，访问权限的大小

指针+-整数

• 指针类型决定指针的步长（指针+1到底跳过几个字节）

char类型      *pc一次访问1个字节，pc+1跳过一个字节
int类型       *pc一次访问4个字节，pc+1跳过4个字节
float类型     *pc一次访问4个字节，pc+1跳过4个字节
double类型    *pc一次访问8个字节，pc+1跳过8个字节
...

3. 野指针

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

3.1 野指针成因

• 指针未初始化

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

• 指针越界访问

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

• 指针指向的空间已释放

比如在一个程序中调用函数

而函数的返回值是地址

函数调用后会自行结束

此时再调用这个地址

如调用这个地址之前没有进行任何占用空间的动作

则此地址所存放的东西不会改变，否则为未知。

int* test()
{int a = 10;return &a;
}
int main()
{int *p = test();//printf("hehe\n");
​printf("%d\n", *p);
​return 0;
}

​

此时值为10，如果在打印前进行另一个占用空间的动作，就会变成这样：

​

3.2 如何规避野指针

1. 指针初始化

2. 小心指针越界

3. 指针指向空间释放，及时置NULL

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

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

......

4. 指针运算

• 指针加减整数

• 指针减指针

• 指针的关系运算

4.1 指针加减整数

类似于数组

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{*vp++ = 0;
}

4.2 指针减指针

前提：两个指针要指向同一块空间

指针减指针的绝对值得到的是两个指针之间的元素个数

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

​

4.3 指针的关系运算

for(vp = &values[N_VALUES]; vp > &values[0];)
{*--vp = 0;
}

代码简化, 这将代码修改如下：

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{*vp = 0;
}

实际在绝大部分的编译器上是可以顺利完成任务的

然而我们还是应该避免这样写，因为标准并不保证 它可行。

标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与 指向第一个元素之前的那个内存位置的指针进行比较。

5. 指针和数组

举例：

#include 
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};printf("%p\n", arr);printf("%p\n", &arr[0]);return 0;
}

 ​

可见数组名和数组首元素的地址是一样的。

结论：数组名表示的是数组首元素的地址。

既然可以把数组名当成地址存放到一个指针中

我们使用指针访问数组就是可行的

例如：

#include 
int main()
{int arr[] = {1,2,3,4,5,6,7,8,9,0};int *p = arr; //指针存放数组首元素的地址int sz = sizeof(arr)/sizeof(arr[0]);int i;for(i=0; i p+%d = %p\n", i, &arr[i], i, p+i);}return 0;
}

 ​

所以 p+i 其实计算的是数组 arr 下标为i的地址。

那我们就可以直接通过指针来访问数组。

如下：

int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
int *p = arr; //指针存放数组首元素的地址
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i

int main() {int arr[10] = { 0,1, 2, 3, 4, 5, 6, 7, 8, 9 };printf("%d==%d?", arr[5], 5[arr]);return 0;
}

int b=20;
*ppa = &b;//等价于pa=&b;

**ppa = 30;
//等价于*pa=30;
//等价于a = 30;

int arr1[5];
char arr2[6];

int* arr3[5];