野指针就是指向的位置是不可知的(随机的、不正确的、没有明确限制的)
1、指针未初始化
2、指针越界
3、指针指向的空间被释放
1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性
空指针的定义:
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);
先看代码:
第一种情况:没有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。 即指针变量名,说明指针的指向不能改变!
#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再解引用是完全不同的。
总结:
指针与整数的运算,指针加减数字表示的意义是指针在数组中位置的移动;
如果指针的类型是 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 个字节;
在讲这个知识点之前,我先补充一句,指针与指针之间是没有加法运算的,虽然能做,但是没有任何意义,所以我们认为不能做加法运算。只有减法运算!
(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。但是这个没有意义。我们算出这样的结果没有意义。指针的减法肯定是要对同一数组做减法才有意义!!
比如:int int_array[4] = {12, 34, 56, 78};int *p_int1 = &int_array[0];int *p_int2 = &int_array[3];
如果两个指针不是指向同一个数组,它们相减就没有意义。记住这句话!!
char *p1;int *p2;