目录

一、指针为何物

1.1 指针的概念

1.2 指针的背后

二、指针和指针类型

2.1 指针的类型

2.2 指针类型的意义

2.2.1 指针 +- 整数（加减）

2.2.2  指针的解引用

三、野指针

3.1 野指针成因

3.2 如何规避野指针

四、指针运算

4.1 指针+-整数

4.2 指针-指针

五、指针和数组

六、二级指针

七、指针数组

一、指针为何物

1.1 指针的概念

       在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”，意思是通过它能找到以它为地址的内存单元

       假设内存块为一栋大楼，每个内存单元为一间房子，每个指针就好比每间房子的门牌号，我们通过门牌号找到相应的房子，同理，我们可以通过指针找到相应的内存单元

指针变量

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量

指针理解的2个要点：

1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

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

例如：

#include<stdio.h>intmain()
{
inta=5;//在内存中开辟一块空间用来存放aint*p=&a; //这里我们对变量a，取出它的地址，可以使用& 操作符。//p 拿到了 a 的地址，把 a 的地址存放在变量 p 中，p就是一个指针变量//对 p 进行解引用操作（也就是 *p）就能找到 a 的地址,相当于拿到了aprintf("%d\n", a);
printf("%d\n", *p);
*p=10;//对指针变量 p 进行解引用拿到 a 的地址，并对 a 的值进行了间接修改printf("%d\n", a);
printf("%d\n", *p);
return0;
}

运行结果

在调试模式下查看

所以说 *p 就相当于 a

总结：

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

----------------我是分割线---------------  

1.2 指针的背后

一个小的单元到底是多大？

答：1个字节

地址如何编址？

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

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

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

000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000002...
...
...
1111111111111111111111111111111011111111111111111111111111111111

这里就有 2 的 32 次方个地址

       每个地址标识一个字节，那我们就可以给 4G 的空闲进行编址,（2^32Byte == 2^32/1024KB == 2^32/1024/1024MB == 2^32/1024/1024/1024GB == 4GB）

同样的方法，64位机器，如果给64根地址线，那能编址多大空间，自己计算

这里我们就明白：

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

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

总结：

指针是用来存放地址的，地址是唯一标示一块地址空间的

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

----------------我是分割线---------------  

二、指针和指针类型

2.1 指针的类型

       这里我们在讨论一下：指针的类型，我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？准确的说：有的

当有这样的代码：

1. int num = 10;
2. 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*的指针，解引用访问 4个字节，如果是char*的指针，解引用访问 1个字节，依次推广到其他类型

----------------我是分割线---------------

2.2 指针类型的意义

2.2.1 指针 +- 整数（加减）

#include <stdio.h>intmain()
{
intn=10;
char*pc= (char*)&n;//强制转换成 char 类型int*pi=&n;
printf("%p\n", &n);
printf("%p\n", pc);
printf("%p\n", pc+1);
printf("%p\n", pi);
printf("%p\n", pi+1);
return0;
}

运行结果

char* 类型的指针 pc+1 结果跳过了一个字节

int*  类型的 指针 pi+1 结果跳过了四个字节（环境为 x86）

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

2.2.2  指针的解引用

测试代码：

#include <stdio.h>intmain()
{
intn=0x11223344;
char*pc= (char*)&n;
int*pi=&n;
*pc=0; //重点在调试的过程中观察内存的变化。*pi=0; //重点在调试的过程中观察内存的变化。return0;
}

在调试下查看

*pc  赋值为 0 之后，n 中的值只有一个字节被改成了 0

*pi 赋值为 0 之后，n 中的所有字节均被改成了 0

这说明了：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）
比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节

指针类型的意义总结：

1、指针的类型决定了指针向前或者向后走一步有多大（距离）
2、指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）

---------------我是分割线---------------

三、野指针

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

3.1 野指针成因

（a）指针未初始化

#include <stdio.h>intmain()
{
int*p;//局部变量指针未初始化，默认为随机值*p=20;
return0;
}

运行结果，编译器无法编译

（b） 指针越界访问

#include <stdio.h>intmain()
{
intarr[10] = { 0 };
int*p=arr;
inti=0;
for (i=0; i<=11; i++)
    {
//当指针指向的范围超出数组arr的范围时，p就是野指针*(p++) =i;
    }
return0;
}

运行结果

（c）指针指向的空间释放

动态内存开辟的时候讲解，这里可以简单提示一下

3.2 如何规避野指针

1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放即使置NULL

1. 避免返回局部变量的地址
2. 指针使用之前检查有效性

----------------我是分割线---------------

四、指针运算

4.1 指针+-整数

上面指针类型的意义里面已经讲过了，这不不谈了

4.2 指针-指针

测试代码

#include<stdio.h>intmy_strlen(char*s)
{
char*p=s;
while (*p!='\0')
p++;
returnp-s;
}
intmain()
{
chars[] ="abcdef";
intret=my_strlen(s);
printf("%d\n", ret);
return0;
}

运行结果

结果说明了指针 - 指针得到的是指针和指针之间的元素个数，但是要注意指针 - 指针的前提是，两个指针必须指向同一块空间

还有一点要注意：指针 +指针没有意义

总结一下：

• 指针和指针进行加减：两个指针不能进行加法运算，这是非法操作，因为进行加法后，得到的结果指向一个不知所向的地方，，而且毫无意义
• 两个指针可以进行减法操作，但必须类型相同，一般用在数组方面
• 标准规定：允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较

五、指针和数组

       数组，是一块连续的空间，里面存放的是相同类型的元素，存储的方式是先使用低地址的空间，再使用高地址的空间，数组名表示的是数组首元素的地址（两种情况除外，后面讲）

指针（变量）--- 是一个变量，存放的是地址

这样写代码是可行的

1. int arr[10] = {1,2,3,4,5,6,7,8,9,0};
2. int *p = arr;//p存放的是数组首元素的地址

数组名当成地址存放到一个指针中，我们就使用指针来访问数组

例如：

#include <stdio.h>intmain()
{
inti=0;
intarr[] = { 1,2,3,4,5,6,7,8,9,0 };
int*p=arr; //指针存放数组首元素的地址intsz=sizeof(arr) /sizeof(arr[0]);
for (i=0; i<sz; i++)
    {
printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p+i);
    }
return0;
}

运行结果

p+i 其实计算的是数组 arr 下标为 i的地址，我们就可以直接通过指针来访问数组

再如，使用指针打印数组

#include <stdio.h>intmain()
{
intarr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
int*p=arr; //指针存放数组首元素的地址intsz=sizeof(arr) /sizeof(arr[0]);
inti=0;
for (i=0; i<sz; i++)
    {
printf("%d ", *(p+i));
    }
return0;
}

运行结果

六、二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址也可以存放在指针里面

如图，这就是二级指针

例如：

1. int b = 20;
2. *pa = &b; //pa是指针变量（一级指针）
3. **ppa = &pa; ///ppa是一个二级指针

*pa 通过对 pa中的地址进行解引用，这样找到的是 b ， *pa 其实访问的就是 b

**ppa 先通过 *pa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 b

----------------我是分割线---------------

七、指针数组

指针数组是指针还是数组？答案：是数组，是存放指针的数组

数组我们已经知道整形数组，字符数组，比如

1. int arr1[5];
2. char arr2[6];

指针数组：存放指针的数组就是指针数组，例如

int* p[5];

p 是一个数组，有五个元素，每个元素是一个整形指针

最后，再进行总结一下

1. int p；//这是一个普通的整型变量
2. int *p； //首先从 p 处开始先与 * 结合,所以说明 p 是一个指针，然后再与int 结合，说明指针所指向的内容的类型为int 型；所以 p 是一个返回整型数据的指针
3. int **p； //首先从 p 开始,先与*结合,说是 p 是一个指针（*p）；然后再与 * 结合；说明指针所指向的元素是指针（**p），然后再与int 结合，说明该指针所指向的元素是整型数据
4. int p[3] ； //首先从 p 处开始，先与 [] 结合,说明 p 是一个数组，然后与int 结合，说明数组里的元素是整型的，所以 p 是一个由整型数据组成的数组
5. int *p[3]； //首先从 p 处开始,先与 [] 结合，因为其优先级比  * 高；所以 p 是一个数组，然后再与 * 结合，说明数组里的元素是指针类型，然后再与int 结合，说明指针所指向的内容的类型是整型的，所以 p 是一个由返回整型数据的指针所组成的数组
   

----------------我是分割线---------------

文章就到这里！