前言：大家好哇！今天带大家认识下C语言中的指针，指针的用法等，希望对大家有所帮助！

目录

一.指针是什么

1.指针是什么？

2.如何理解指针变量

二.指针和指针的类型

1.指针类型

2.指针类型的意义

（1)指针类型决定了指针解引用时，能够访问的内存大小是多少

（2）指针加减整数

（3）指针修改数组元素

三.野指针

1.野指针的概念

2.野指针的成因

（1）指针未初始化

（2）指针越界访问

（3）指针指向的空间已经释放

 3.那该如何规避野指针问题？

四.指针运算

1.指针加整数

2.指针减整数

4.指针减指针

5.指针的关系运算

五.指针和数组

1.数组名

2.使用指针访问数组

六.二级指针

七.指针数组

一.指针是什么

1.指针是什么？

理解指针是什么首先要引入内存-------电脑上的一种存储设备，分4/8/16GB。

如上图所示：我们把整个内存划分为一个个小的内存单元，每个内存单元的大小是一个字节，然后将这些内存单元进行编号，未来我们想使用哪一个内存单元时只需要知道对应的编号就能找到，这个编号就叫做内存单元的地址，也就是C语言中的指针。

那么这里还有一个问题，我们是如何给内存单元编号的呢？

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

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000001

.......

111111111 111111111 111111111 111111111

 总共有个地址，每个地址对应一个内存空间，每个内存空间的大小为一个字节，那么我们就能对4G的空间进行编址寻址了。

2.如何理解指针变量

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

所以指针变量是用来存放地址的变量，我们平时口语所说的指针指的就是指针变量。

上文提到，在32位机器上，地址是由32个0或1组成的二进制（bit)序列，那地址就得占4个字节，需要4个字节的空间来存储，所以一个指针变量的大小为4个字节。

同理，64位机器上，一个指针变量的大小为8个字节。

总结：

1. 指针就是地址，地址就是指针；
2. 指针变量就是变量，用来存放地址的变量（存放在之中的值都被当成地址处理）；
3. 一个小的内存单元大小为 1 个字节；
4. 指针是用来存放地址的，地址是唯一标识一块内存空间的；
5. 指针的大小在 32 位平台上是 4 个字节，在 64 位平台上是 8 个字节；

二.指针和指针的类型

1.指针类型

指针的本质是地址。

int main()
{int a = 0x11223344;int* pa = &a;char* pc = &a;printf("%p\n", pa);printf("%p\n", pc);return 0;
}

上面int 型指针pa和char型指针pc都可以存储a，他们的运行结果是一样的。

2.指针类型的意义

（1)指针类型决定了指针解引用时，能够访问的内存大小是多少

int  *p         //*p能够访问4个字节

char *p       //*p能够访问4个字节

double *p   //*p能够访问4个字节

.......

不同的指针类型，访问的大小不同：

int main()
{int a = 0x11223344;int* pa = &a; // 44 33 22 11 (至于为什么是倒着的，后面会讲。)*pa = 0;// 00 00 00 00char* pc = &a; // 44 33 22 11*pc = 0; // 00 33 22 11    // 在内存中仅仅改变了一个字节// 解引用操作时就不一样了：// 整型指针操作了4个字节，让四个字节变为0// 字符指针能把地址存到内存中，但是解引用操作时，只能动1个字节return 0;
}

（2）指针加减整数

公理：指针类型决定指针步长（指针走一步多远）

int *p；p+1              //跳过4个字节

char *p；p+1           //跳过1个字节

double *p；p+1       //跳过8个字节

int main()
{int a = 0x11223344;int* pa = &a;char* pc = &a;printf("%p\n", pa);   // 0095FB58printf("%p\n", pa+1); // 0095FB5C +4printf("%p\n", pc);   // 0095FB58printf("%p\n", pc+1); // 0095FB59 +1return 0;
}

（3）指针修改数组元素

int main()
{int arr[10] = {0};int brr[10] = {0};int* pa = arr; //数组名 - 首元素地址char* pc= brr;/* 修改 */int i = 0;for(i=0; i<10; i++) {*(pa+i) = 1; //成功，arr里的元素都变为了1}for(i=0; i<10; i++) {*(pc+i) = 1; //不成功,只能一个字节一个字节的改，只改动了10个字节。}/* 打印 */for(i=0; i<10; i++) {printf("%d ", arr[i]);printf("%d ", brr[i]);}return 0;
}

这是因为：char*的指针解引用只能访问一个字节 

总结：

 指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）；

 譬如，char* 的指针解引用只能访问1个字节，而 int* 的指针解引用就能够访问4个字节

三.野指针

1.野指针的概念

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

2.野指针的成因

1.  指针未初始化；
2. 指针越界访问；
3. 指针指向的空间已释放；

（1）指针未初始化

int main()
{int *p; //初始化随机值*p = 20; //*p未初始化就使用，虽然有指向的对象，但其存放的内存是随机的return 0;
}

（2）指针越界访问

常出现在数中

int main()
{int arr[10] = {0};int *p = arr;int i = 0;for(i=0; i<12; i++){//当指针越出arr管理的范围时，p就称为野指针p++;}return 0;
}

（3）指针指向的空间已经释放

int* test()
{int a = 10;return &a;
}int main()
{int *pa = test();*pa = 20;return 0;
}

 这是因为：

• 一进入test 函数内时就创建一个临时变量 a，这个a是局部变量，进入函数时创建，一旦出去就销毁，销毁就意味着这个内存空间还给了操作系统，这块空间就不再是 a 的了；
• 进入这个函数时创建了 a，有了地址，ruturn &a 把地址返回去了，但是这个函数一结束，这块空间就不属于自己了，pa调用使用时，这块空间已经释放了，指针指向的空间被释放了，这种情况就会导致野指针的问题；
• 只要是返回临时变量的地址，都会存在问题（除非这个变量出了这个范围不销毁）；

 3.那该如何规避野指针问题？

答：乖乖初始化，指针指向空间释放及时置空，指针使用前检查有效性。

//初始化
int main()
{int a = 10;int* pa = &a;  // 初始化int* p = NULL; // 当你不知道给什么值的时候用NULLreturn 0;
}
//不想用了就置空
int main()
{int a = 10;int *pa = &a;*pa = 20;//假设已经把a操作好了，pa指针已经不打算用它了pa = NULL; //置成空指针return 0;
}
//指针使用前检查有效性
int main()
{int a = 10;int *pa = &a;*pa = 20;pa = NULL; //*pa = 10; 崩溃，访问发生错误，指针为空时不能访问if(pa != NULL) { // 检查 如果指针不是空指针*pa = 10; // 检查通过才执行}  return 0;
}

四.指针运算

1.指针加整数

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

int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9,10};int i = 0;int sz = sizeof(arr) / sizeof(arr[0]);int* p = &arr[9]; // 取出数组最后一个元素的地址for(i=0; i

int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9,10};printf("%d\n", &arr[9] - &arr[0]); // 得到指针和指针之间元素的个数9return 0;
}
//错位示范:
int ch[5] = {0};
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
printf("%d\n", &arr[9] - &ch[0]); // 没有意义，结果是不可预知的

//用指针方法实现；
int my_strlen(char* str)
{char* start = str;char* end = str;while(*end != '\0') {end++;}return end - start; //return}//用指针间做差化简：
int my_strlen(const char* str)
{const char* end = str;while(*end++);return (end - str - 1);
}int main()
{//strlen - 求字符串长度//递归 - 模拟实现了strlen - 计数器方式1， 递归的方式2char arr[] = "abcdef";int len = my_strlen(arr); //arr是首元素的地址printf("%d\n", len);return 0;
}

//vp从最大位置的后一个内存位置的指针开始比较
for(vp = &values[N_VALUES]; vp > &values[0];) 
{*--vp = 0;
}

//最后一次比较是vp与数组首元素的前一个内存位置的指针进行比较
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)  
{*vp = 0;
}

int main()
{int arr[10] = {0};int* p = arr;  // 用指针访问数组, arr为数组首元素的地址int i = 0;for(i=0; i<10; i++) {printf("%d ", arr[i]);  }for(i=0; i<10; i++) {*(p+i) = i;   //用指针对数组进行赋值操作}for(i=0; i<10; i++) {printf("%d ", arr[i]);}return 0;
}

int main()
{int a = 10;int* pa = &a;int** ppa = &pa; // ppa是二级指针int*** pppa = &ppa; // pppa是三级指针...**ppa = 20;printf("%d\n", **ppa); // 20printf("%d\n", a);  // 20return 0;
}

int a = 10;
int b = 20;
int c = 30;
int arr1[10];//arr1是一个存放整型的数组
int* arr2[3] = { &a,&b,&c };//arr2是一个存放整型指针的数组

//打印a，b，c的值
for(int i=0;i<3;i++)
{printf("%d",*arr2[i]);
}