提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
目录
前言
在经历前面的学习后，开始进入C语言的指针学习部分，它较难理解掌握；但通过指针，可以简化一些 C 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。
每一个变量都有一个内存位置，每一个内存位置都定义了可使用 &运算符访问的地址，它表示了在内存中的一个地址。
一、指针是什么？
指针是什么？指针理解的 2 个要点：1. 指针是内存中一个最小单元的编号，也就是地址2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
举身边例子：某一天，小明在集市上遇到了许久未见的老同学小李，然后他们嘘寒问暖了好一阵，小李便递了张字条给小明，说道：“小明阿，有空来我家坐坐。”。小明打开小李给的字条，上面写着小李家的地址，那么可以将小李家的地址认为是指针，而写着小李家地址的纸条认为是指针变量。通过上面的例子，可以进一步的理解指针和指针变量的区别：指针也就是内存地址，指针变量是用来存放内存地址的变量。
总结：指针就是地址，口语中说的指针通常指的是指针变量。
二、指针变量的创建和指针类型
2.1 指针变量的定义
我们可以通过 & （取地址操作符）取出变量的内存起始地址，把地址可以存放到一个变量中，这个 变量就是指针变量
指针变量跟其他变量或常量一样，必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为： type *var_name；
type 是指针的基类型，它必须是一个有效的 C 数据类型，例如：int/float/double/char等。
var_name 是指针变量的名称，用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。
所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个代表内存地址的长的十六进制数。
不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。
2.2 指针变量的创建
下面是创建一个指针的，代码如下（示例）：
#include<stdio.h>
int main() {
int a = 10;//在内存中开辟一块空间
int* p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。
printf("a变量的地址为：%p", &a);
printf("p指针变量存储的地址为：%p", p);
printf("p指针变量的地址为：%p", &p);
return 0;
}
//输出结果：
//a变量的地址为： 000000A584AFFB34
//p指针变量存储的地址为： 000000A584AFFB34
//p指针变量的地址为： 000000EAC14FF838观察输出结果，发现p指针变量存储的是变量a的地址，同时p这个指针变量也有它自己的地址。所以指针变量，是用来存放地址的变量。（存放在指针中的值都被当做地址处理，这里的指针是指指针变量）。
看到这里你心中可能会有这样的疑问：
- 一个小的单元到底多大？（1个字节）
- 然后编址？
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）；
00000000 00000000 00000000 0000000000000000 00000000 00000000 00000001...（此处省略29行）11111111 11111111 11111111 11111111
这里就有2的32次方个地址。
每个地址标识一个字节，那我们就可以给 （2^32Byte == 2^32/1024 KB == 2^32/1024/1024 MB == 2^32/1024/1024/1024 GB == 4GB） 4G的空间进行编址。 同样的方法，那64位机器，如果给64根地址线，那能编址多大空间，自己计算。
- 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以 一个指针变量的大小就应该是4个字节。
- 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。
小结：
- 指针变量是用来存放地址的，地址是唯一标示一个内存单元的。
- 指针的大小在32位平台是4个字节，在64位平台是8个字节。
2.3 指针变量的类型
我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？ 答案是：有的。
观察下面这段代码：
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 类型变量的地址。
其他类型同理。
2.4 NULL 指针（空指针）
在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。NULL 指针是一个定义在标准库中的值为零的常量
#include <stdio.h>
int main (){
int *p = NULL;
printf("p 的地址是 %p\n", p );
return 0;
}
结果：
p 的地址是 0x0
在大多数的操作系统上，程序不允许访问地址为0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。
如果需要检查一个指针是否为空，可以使用if进行判断：
if (p == null){
printf("p为空指针\n");
}
else{
printf("p不为空指针\n");
}
三、指针的使用
看到这里，也许你已经知道，指针变量是用来存储变量地址的，那么指针类型有什么用呢？同时指针类型的意义是什么？透过下面的例子，来看看它的应用。
3.1 指针+-整数
#include <stdio.h>
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;
}
//输出结果：
//变量n的地址为： 0000005FFDDDF634
//变量pc指向的地址为： 0000005FFDDDF634
//变量pc+1指向的地址为：0000005FFDDDF635
//变量pi指向的地址为： 0000005FFDDDF634
//变量pi+1指向的地址为：0000005FFDDDF638指针的类型决定了指针向前或者向后走一步有多大（距离）。pc是char*类型的指针，pc指针向前或者向后走一步，是走一个char类型大小（1字节==8bit）的距离,观察输出结果发现，pc指向的地址为： 0000005FFDDDF634，而pc + 1指向的地址为：0000005FFDDDF635，相差距离刚好为1个char类型的大小（1个字节）；而pi是int*类型的指针，pc指针向前或者向后走一步，是走一个int类型大小（4字节==4*8bit）的距离。
小结：指针的类型决定了指针向前或者向后走一步有多大（距离）。
3.2 指针的解引用
#include <stdio.h>
int main()
{
int n = 0x11223344;
char* pc = (char*)&n;
int* pi = &n;
*pc = 0; //重点在调试的过程中观察内存的变化。
*pi = 0; //重点在调试的过程中观察内存的变化。
return 0;
}
//大小端的概念：
//对于一个由2个字节组成的16位整数，在内存中存储这两个字节有两种方法：
// 一种是将低序字节存储在起始地址，这称为小端(little - endian)字节序；
//另一种方法是将高序字节存储在起始地址，这称为大端(big - endian)字节序。
//内存观察结果
//pc指针 44 33 22 11 （小端）---> 00 33 22 11
//pi指针 44 33 22 11 （小端）---> 00 00 00 00观察输出结果可以发现，不同类型的指针，一次可以操作的字节个数是不同的。
对于pc指针，它的类型是char*,它一次可以操作1个字节，所以当指向*pc=0时（对指针指向的地址内容进行修改），它只将44这一字节的内容置为00，整体输出为 00 33 22 11；而对于pi指针，它的类型是int*,它一次可以操作4个字节，所以当指向*pi=0时（对指针指向的地址内容进行修改），它将44 33 22 11 这四个字节的内容置为00 00 00 00。
小结：
3.3 野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
依旧拿开头例子，对野指针概念进行具象化。小明在拿打小李的纸条后，由于天空下起了小于，把小李家地址中的某一个数字打湿了。某一天，小明一时兴起，准备去找小李叙旧，这时候小明拿出纸条，按照纸条上面地址找小李时，找到的很可能不是小李的家。可以认为这时候的纸条（指针）指向的地址可能不是小李的家，指向的可能是某个人的家，或者什么也不是，是不确定的，随机的，那么就可以将这个纸条认为是野指针。
3.3.1 野指针的成因
1. 指针未初始化
int main()
{
int* p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}
//这里使用的是vs2022直接进行报错，error C4700: 使用了未初始化的局部变量“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;
}
运行结果：
Stack around the variable 'arr' was corrupted. 出现堆栈的问题，这种情况下一般就是出现数组越界的情况。
3. 指针指向的空间释放
3.3.2 如何规避野指针
1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放，及时置NULL
4. 避免返回局部变量的地址
四、指针的运算
4.1 指针+-整数
#include <stdio.h>
#define N_VALUES 5
int main() {
float values[N_VALUES];
float* vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}
for (int i = 0; i < N_VALUES; i++) {
printf("%f ", values[i]);
}
return 0;
}在段代码，是将浮点类型数组的首地址给指针vp，如果将vp存储地址所指向的内容置零，然后vp地址+1（4字节），直到vp存储的地址到达数组末位元素的地址；整体来看，实现的是数组的初始化功能。
4.2 指针-指针
利用指针计算字符串的长度 ，将字符串首元素地址传给my_strlen函数，由指针接收字符串首元素地址（作为起始地址）；再创建一个指针p（记录终止位置）由起始位置开始，一个一个往字符串的后面走（char类型指针一次走1个字节的距离），直到遇到‘\0'（字符串结束符），最后将终止位置的地址 - 起始地址，那么就是字符串的长度。
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;
}实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。
五. 指针和数组
看下面一个例子：
#include <stdio.h>
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;
}
//输出结果：
//000000586175F6C8
//000000586175F6C8可见数组名和数组首元素的地址是一样的。 结论：数组名表示的是数组首元素的地址。（2种情况除外，
- sizeof内部放一个数组名，这个时候的数组名表示的是整个数组，同样计算的是整个数组的大小，单位是字节
- 取地址&数组名，这里的数组名表示整个数组，取出的是整个数组的地址
）
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr; //p存放的是数组首元素的地址#include <stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
int* p = arr; //指针存放数组首元素的地址
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p + i);
}
return 0;
}运行结果：
所以 p+i 其实计算的是数组 arr 下标为i的地址。 那我们就可以直接通过指针来访问数组。 如下：
#include <stdio.h>
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 < sz; i++)
{
printf("%d ", *(p + i));
}
return 0;
}六、二级指针
指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？ 这就是 二级指针 。
对于二级指针的运算有：
- *pp 通过对pp中的地址进行解引用，这样找到的是 p ， *pp 其实访问的就是 p.
int b = 20;
*pp = &b;//等价于 p = &b;- **pp 先通过 *pp 找到 p ,然后对 p 进行解引用操作： *p ，那找到的是 a .
**pp = 30;
//等价于*p = 30;
//等价于a = 30;七、指针数组
指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
数组我们已经知道整形数组，字符数组。
int arr1 [ 5 ];char arr2 [ 6 ];
那指针数组是怎样的？
int* arr3[5];//是什么？
arr3是一个数组，有五个元素，每个元素是一个整形指针。
扫一扫
366
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
