C++学习day--16 野指针和空指针

1、什么是野指针？

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

造成野指针的原因：

1、指针未初始化

2、指针越界

3、指针指向的空间被释放

规避野指针的方法： 

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

2、空指针 

空指针，就是值为 0 的指针 。（ 任何程序数据都不会存储在地址为 0 的内存块中 ，它是被操作系 统预留的内存块。）

空指针的定义：

int *p = 0;

或者

int *p = NULL; // 强烈推荐，在VS编译器中，把NULL转到定义发现，NULL的值就是0

 空指针的使用：

1）指针初始化为空指针，目的就是，避免访问非法数据。

int *select = NULL;

2 ）指针不再使用时，可以设置为空指针，也是防御式编程，避免指针成为野指针

int *select = &xiao_long_lv;

select = NULL;

3)指针 使用前进行合法性判断

int *p = NULL;

if (p) {  //p 等同于 p!=NULL

// 指针不为空，对指针进行操作

}

 坏指针的使用：

坏指针的定义：坏指针就是没有初始化的指针，或者非法赋值的指针，比如给指针赋值一个整数！

情形一：

int *select; // 没有初始化

printf(" 选择的房间是： %d\n", *select);

在新版本的VS编译器是编译有警告，运行出错！在老版本VC2010可以运行，结果为 0xCCCCCCCC，这个表示一个随机值，现在的编译器更为严格，直接不让运行。

情形二：

select = 100;

printf(" 选择的房间是： %d\n", *select);

3、const关键字的使用

先看代码：

第一种情况：没有const的情况，指针变量能改变，所指向的空间也能改变

#include 
#include 
//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 
#include 
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
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 
#include 
#include 

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

运行结果：

 

 这个结果发现，原来字符串已经该变了，虽然实现了逆转，但是不符合题目要求。这个不是通过指针实现的，是还没学习指针前的做法，现在学了指针，用指针试试：

#include 
#include 
#include 

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

运行结果：

 

 这个就是倒序打印，没什么算法思想在里面，在这里我要说一点就是代码：*p--或者*p++，这个是先解引用，p再减减，或者再加加。如果想让p先减减或者先加加再解引用，代码这样写：

*(--p)或者*(++p)

写成这样：

*(p--)或者*(p++) ,这样等价于还是先解引用再减减或者加加。

指针与整数之间的加减运算：

#include 
#include 
#include 
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再解引用是完全不同的。

总结：

指针与整数的运算，指针加减数字表示的意义是指针在数组中位置的移动；

对于整数部分而言，它代表的是一个元素，对于不同的数据类型，其数组的元素占

用的字节是不一样的，

比如指针 + 1，并不是在指针地址的基础之上加 1 个地址，而是在这个指针地址的

基础上加 1 个元素占用的字节数：

 如果指针的类型是 char*，那么这个时候 1 代表 1 个字节地址；

如果指针的类型是 int*，那么这个时候 1 代表 4 个字节地址；

 如果指针的类型是 float*，那么这个时候 1 代表 4 个字节地址；

如果指针的类型是 double*，那么这个时候 1 代表 8 个字节地址。

通用公式：

数据类型 *p;

p + n 实际指向的地址： p 基地址 + n * sizeof( 数据类型 )

p - n 实际指向的地址： p 基地址 - n * sizeof( 数据类型 )

比如：

（ 1 ）对于 int 类型，比如 p 指向 0x0061FF14 ，则：

p+1 实际指向的是 0x0061FF18 ，与 p 指向的内存地址相差 4 个字节；

p+2 实际指向的是 0x0061FF1C ，与 p 指向的内存地址相差 8 个字节

（2）对于 char 类型，比如 p 指向 0x0061FF28 ，则：

p+1 实际指向的是 0x0061FF29 ，与 p 指向的内存地址相差 1 个字节；

p+1 实际指向的是 0x0061FF2A ，与 p 指向的内存地址相差 2 个字节；

 5、指针与指针之间的减法运算：

在讲这个知识点之前，我先补充一句，指针与指针之间是没有加法运算的，虽然能做，但是没有任何意义，所以我们认为不能做加法运算。只有减法运算！

（1）使用“指针-指针”的方式计算整数数组元素的偏移值；
 

#include 
#include 

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。但是这个没有意义。我们算出这样的结果没有意义。指针的减法肯定是要对同一数组做减法才有意义！！

总结：

（ 1 ）指针和指针可以做减法操作，但不适合做加法运算；

（2）指针和指针做减法适用的场合：两个指针都指向同一个数组， 相减结果为两个指针之

间的元素数目，遵循左闭右开原则 ，而不是两个指针之间相差的字节数。

比如：

int int_array[4] = {12, 34, 56, 78};

int *p_int1 = &int_array[0];

int *p_int2 = &int_array[3];

p_int2 - p_int1 的结果为 3 ，即是两个之间之间的元素数目为 3 个。

如果两个指针不是指向同一个数组，它们相减就没有意义。记住这句话！！

（3） 不同类型的指针不允许相减 ，比如

char *p1;

int *p2;

p2-p1 是没有意义的。而且现在在新版本VS编译器编译都通不过。

今天的内容就学到这里，希望慢慢消化一下。