1、什么是野指针？
野指针就是指向的位置是不可知的（随机的、不正确的、没有明确限制的）
造成野指针的原因：
1、指针未初始化
2、指针越界
3、指针指向的空间被释放
规避野指针的方法：
1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性
2、空指针
空指针的定义：
int *p = 0;或者int *p = NULL; // 强烈推荐，在VS编译器中，把NULL转到定义发现，NULL的值就是0
空指针的使用：
int *select = NULL;
int *select = &xiao_long_lv;select = NULL;
int *p = NULL;if (p) { //p 等同于 p!=NULL// 指针不为空，对指针进行操作}
坏指针的使用：
坏指针的定义：坏指针就是没有初始化的指针，或者非法赋值的指针，比如给指针赋值一个整数！
int *select; // 没有初始化printf(" 选择的房间是： %d\n", *select);
select = 100;printf(" 选择的房间是： %d\n", *select);
3、const关键字的使用
先看代码：
第一种情况：没有const的情况，指针变量能改变，所指向的空间也能改变
#include <stdio.h>
#include <stdlib.h>
//const 和指针
int main(void) {
int wife = 24;
int girl = 18;
//第一种 渣男型
int* zha_nan = &wife;
*zha_nan = 25;
zha_nan = &girl;
*zha_nan = 19;
printf("girl : %d wife: %d\n", girl, wife);
return 0;
}运行结果：
第二种情况：const修饰int，有两种写法
第一种写法：const写在int后面
int const* p=NULL
第二种写法：const写在int前面
const int *p=NULL
两种写法都是等价的，const都是修饰int，什么意思呢？就是说const修饰的指针变量本身可以改变，但是指向的那块空间的内容不能改变！！因此上面两个代码报错的原因是指针变量p指向的空间不能改变！！因此报错。
怎么记忆这两种写法呢？因为会和后面的const修饰指针变量容易混淆！只需要记住一点，const离谁近就修饰谁，有符号‘*’的地方更远即可。如 int const *p，const离int和离指针变量p一样近，但是指针变量p前面有‘*’隔开，所以距离更远，因此const修饰的是int !!
注释掉错误代码运行，结果如下：
结果表明：虽然指针p指向的那块空间不能被改变，但是指针变量p本身的指向是可以改变的！
第三种情况：const修饰指针变量
为什么const修饰的是指针变量，通过上面的方法，我想const修饰什么自己应该能很清晰地分清楚。
因为const修饰的是指针变量，因此指针变量指向的值不能变，也就是指针变量不能再指向别的地址了，因此代码最后一行那里报错了。
注释掉报错运行：运行结果：
第四种情况：
有两个const，很明显，一个离int近，一个离指针变量近，说明两个都修饰，那么也就是说指针变量不能变，所指向的空间也不能改变。但是不是说原来的整形变量不能改变，只是说不能通过解引用来改变指向的空间的值！本案例中，语句：wife=90;是正确的，但是*super_nuam_nan=90;就是错的。
总结： 看 const 离类型(int)近，还是离指针变量名近，离谁近，就修饰谁，谁就不能变。这个总结很棒，就是看const是离int近还是离变量名近，* 号作为间隔符，也就是有*的地方距离就要远一点，例如： int * const p=&b，const修饰的是p，因为前面int中间有* 隔开，因此距离要远一点！！所以修饰的不是int，而是p。 即指针变量名，说明指针的指向不能改变！
4、指针与整数的算术运算：（重中之重）
指针自增：
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int ages[] = { 21,15,18,14,23,28,10 };
int len = sizeof(ages) / sizeof(ages[0]);
for (int i = 0; i < len; i++) { //使用数组的方式来访问数组
printf("第%d 个学员的年龄是:%d\n", i + 1, ages[i]);
}
//打印数组的地址和第一个成员的地址
printf("ages 的地址: 0x%p , 第一个元素的地址: 0x%p\n", ages,&ages[0]);
int* p = ages;
printf("数组的第一个元素：%d\n", *p);//访问第一个元素
p++; //访问第二个元素,注意这里 p = p+ 1*(sizeof(int))
printf("数组的第二个元素：%d\n", *p);
p = ages;//指针p重新指向数组ages
for (int i = 0; i < len; i++) {
printf("数组的第%d 个元素：%d 地址:0x%p\n", i + 1, *p, p);
p++;
}
printf("------------------------\n");
return 0;
}运行结果：
通过下标访问数组不用多说，想必已经很熟悉了。 主要是讲一下下面的代码，对数组地址和数组首元素地址这里有必要说一下，数组地址指的是整个数组的地址，数组首元素地址指的是第一个元素的地址，虽然他们在值上是一样的，但是意义不一样。还有就是数组名就是一个指针，指向首元素的地址。
通过指针指向数组首元素地址来访问数组，发现指针每次跳跃了4个字节，刚好是int类型的大小。推断：指针p+1跳跃的是指针类型的大小。
#include<stdio.h>
int main() {
char ch[4] = { 'a','b','c','d' };
char* cp = ch;
for (int i = 0; i < 4; i++) {
printf("数组的第%d 个元素：%c 地址:0x%p\n", i + 1, *cp, cp);
cp++;
}
//总结： p++ 的概念是在 p 当前地址的基础上 ,自增 p 对应类型的大小 p= p + 1 * (sizeof(类型))
return 0;
}运行结果：
而我们知道，char类型占一个字节，通过运行结果可以知道，指针加1就是跳跃指针类型的大小：
指针p + n 跳跃了（指针的类型大小）*4个字节。
画图理解：
总结： p++ 的概念是在 p 当前地址的基础上 ,自增 p 对应类型的大小, 也就是说 p = p+ 1*(sizeof(类型))
指针自减：
先有一个问题：让用户输入一个字符串，然后反向输出，注意：不能改变原来的字符串！ 如： "12345" 逆转成 "54321" 输出。代码实现如下：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
char input[128];
int len;
char tmp;
scanf_s("%s", input, 128);
printf("%s逆转后：",input);
len = strlen(input);
//方法 1 交换
for( int i=0; i<len/2; i++){
tmp = input[i];
input[i] = input[len-i-1];
input[len-i-1] = tmp;
}
for(int i=0; i<len; i++){
printf("%c", input[i]);
}
printf("\n%s\n", input);
return 0;
}运行结果：
这个结果发现，原来字符串已经该变了，虽然实现了逆转，但是不符合题目要求。这个不是通过指针实现的，是还没学习指针前的做法，现在学了指针，用指针试试：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
char input[128];
int len;
char tmp;
scanf_s("%s", input, 128);
printf("%s逆转后：",input);
len = strlen(input);
//第二种方法
char* p = &input[len - 1];
for (int i = 0; i < len; i++) {
printf("%c", *p--);
}
printf("\n");
for(int i=0; i<len; i++){
printf("%c", input[i]);
}
return 0;
}
运行结果：
这个就是倒序打印，没什么算法思想在里面，在这里我要说一点就是代码：*p--或者*p++，这个是先解引用，p再减减，或者再加加。如果想让p先减减或者先加加再解引用，代码这样写：
*(--p)或者*(++p)
写成这样：
*(p--)或者*(p++) ,这样等价于还是先解引用再减减或者加加。
指针与整数之间的加减运算：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
int ages[] = { 20,18,19,24,23,28,30,38, 35, 32 };
int len = sizeof(ages) / sizeof(ages[0]);
int* p = ages;
printf("第 7 个美女的年龄: %d\n", *(p + 6));//30
printf("*p+6 = : %d\n", *p + 6);//26
printf("第 3 个美女的年龄: %d\n", *(p + 2));//19
int* p1 = &ages[4];
printf("相对于第 5 个美女，她的前一位的年龄: %d\n", *(p1 - 1));//24
printf("相对于第 5 个美女，她的前三位的年龄: %d\n", *(p1 - 3));//18
return 0;
}运行结果：
其实指针与整数的加法减法我们已经很熟悉了，就是在原来基础位置偏移 n*(指针类型的大小) ，但是这里注意第二句代码，它是先解引用再加6，所以得到的结果是26。和先加6再解引用是完全不同的。
总结：
指针与整数的运算，指针加减数字表示的意义是指针在数组中位置的移动；
如果指针的类型是 char*，那么这个时候 1 代表 1 个字节地址；如果指针的类型是 int*，那么这个时候 1 代表 4 个字节地址；如果指针的类型是 float*，那么这个时候 1 代表 4 个字节地址；如果指针的类型是 double*，那么这个时候 1 代表 8 个字节地址。
p+1 实际指向的是 0x0061FF18 ，与 p 指向的内存地址相差 4 个字节；p+2 实际指向的是 0x0061FF1C ，与 p 指向的内存地址相差 8 个字节
p+1 实际指向的是 0x0061FF29 ，与 p 指向的内存地址相差 1 个字节；p+1 实际指向的是 0x0061FF2A ，与 p 指向的内存地址相差 2 个字节；
5、指针与指针之间的减法运算：
在讲这个知识点之前，我先补充一句，指针与指针之间是没有加法运算的，虽然能做，但是没有任何意义，所以我们认为不能做加法运算。只有减法运算！
（1）使用“指针-指针”的方式计算整数数组元素的偏移值；
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int ages[10] = { 20,18,19,24,23,28,30,38, 35, 32 };
int ages1[4] = { 18, 19, 20, 22 };
int len = sizeof(ages) / sizeof(ages[0]);
int* martin = ages + 6;
int* rock = ages + 9;
printf("rock - martin = %d\n", rock - martin);
printf("martin - rock = %d\n", martin - rock);
martin = ages + 6;
rock = ages1 + 3;
printf("martin: %p rock: %p rock-martin: %d\n", martin, rock, rock - martin);
system("pause");
return 0;
}运行结果：
从运行结果我们可以断定， 指针的减法是指针之间的元素个数，从小的位置算起，遵循左闭右开区间，即最后一个元素不算！但是后面那个结果13是怎么得来的呢？两个地址相减得到16进制数0X34,即十进制52，除以每个元素大小四个字节刚好等于13。但是这个没有意义。我们算出这样的结果没有意义。指针的减法肯定是要对同一数组做减法才有意义！！
比如：int int_array[4] = {12, 34, 56, 78};int *p_int1 = &int_array[0];int *p_int2 = &int_array[3];
如果两个指针不是指向同一个数组，它们相减就没有意义。记住这句话！！
char *p1;int *p2;
129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
