💓博主csdn个人主页：小小unicorn
⏩专栏分类：C语言
🚚代码仓库：小小unicorn的代码仓库🚚
🌹🌹🌹关注我带你学习编程知识

指针是什么

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

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

指针的定义

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

官方对指针的定义，其实我们可以理解为：在内存中，内存被细分为一个个大小为一个字节的内存单元，每一个内存单元都有自己对应的地址。

我们可以将这些内存单元形象地看成一个个的房间，将内存单元（房间）对应的地址形象地看成房间的门牌号。而我们通过门牌号（地址）就可以唯一的找到其对应的房间（内存单元），即地址指向对应内存单元。所以说，可以将地址形象化的称为“指针”。

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

#include<stdio.h>
int main()
{int a = 10;//在内存中开辟一块空间int* p = &a;//将a的地址取出，放到指针变量p中return 0;
}

总结：

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

指针的大小

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

经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）；

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

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

同样的算法，在64位的机器上一共能产生 2⁶⁴ 个不同的地址。

2³² 可以用32个bit位进行存储，而8个bit位等价于1个字节，所以在32位的平台下指针的大小为4个字节。

2⁶⁴ 可以用64个bit位进行存储，所以在64位的平台下指针的大小为8个字节。

这里我们就明白：

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

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

总结：

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

指针类型

指针有哪些类型

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

准确的说：有的。

当有这样的代码：

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类型的变量地址；
int *类型的指针存放的是int类型的变量地址；
float * 类型的指针存放的是float类型的变量地址等。

指针类型的意义：

指针±整数：

若指针类型为int * 的指针+1，那么它将跳过4个字节的大小指向4个字节以后的内容：

若指针类型为char * 的指针+1，那么它只会跳过1个字节的大小指向下一个字节的内容，以此类推。

指针解引用：

指针的类型决定了指针解引用的时候能够访问几个字节的内容。

若指针类型为int *，那么将它进行解引用操作，它将可以访问从指向位置开始向后4个字节的内容：

若指针类型为char *，那么将它进行解引用操作，它将可以访问从指向位置开始向后1个字节的内容，以此类推。

总结：

1.指针的类型决定了指针向前或向后走一步有多大距离。
2.指针的类型决定了指针在进行解引用操作时，能向后访问的空间大小。

野指针

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

野指针的成因

1.指针未初始化

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

局部指针变量p未初始化，默认为随机值，所以这个时候的p就是野指针。
2.指针越界访问

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

当指针指向的范围超出arr数组时，p就是野指针。
3.指针指向的空间被释放

#include<stdio.h>
int* test()
{int a = 10;return &a;
}
int main()
{int* p = test();return 0;
}

指针变量p得到地址后，地址指向的空间已经释放了，所以这个时候的p就是野指针。（也就是说：局部变量出了自己的作用域就会被释放）

如何避免野指针

1.指针初始化
当指针明确知道要存放某一变量地址时，在创建指针变量时就存放该变量地址。当不知道指针将要用于存放哪一变量地址时，在创建指针变量时应置为空指针（NULL）。

#include<stdio.h>
int main()
{int a = 10;int* p1 = &a;//明确知道存放某一地址int* p2 = NULL;//不知道存放哪一地址时置为空指针return 0;
}

2. 小心指针越界
3. 指针指向空间释放，及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性

指针运算

指针±整数

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

指针-指针

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

指针-指针的绝对值是是两个指针之间的元素个数。

指针的关系运算

指针的关系运算，即指针之间的大小比较。
我们如果要将一个数组中的元素全部置0，可以有两种方法。

第一种：从前向后置0

#include<stdio.h>
int main()
{int arr[5] = { 1, 2, 3, 4, 5 };int* p = &arr[0];for (p = &arr[0]; p <= &arr[4]; p++){*p = 0;}return 0;
}

最终指向数组最后一个元素后面的那个内存位置的指针将与&arr[4]比较，不满足条件，于是结束循环。

第二种：从后向前置0

#include<stdio.h>
int main()
{int arr[5] = { 1, 2, 3, 4, 5 };int* p = &arr[4];for (p = &arr[4]; p >= &arr[0]; p--){*p = 0;}return 0;
}

最终指向第一个元素之前的那个内存位置的指针将与&arr[0]比较，不满足条件，于是结束循环。

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

总结：

这两种方法在绝大部分编译器下均能将arr数组中的元素置0，但是我们要尽量使用第一种方法，因为标准并不保证第二种方法可行。

二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
这就是二级指针。

对于二级指针的运算有：
*ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa .

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

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

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

总结：

存放普通变量的地址的指针叫一级指针，存放一级指针变量的地址的指针叫二级指针，存放二级指针变量地址的指针叫三级指针，以此类推。