大家好啊,我是小象٩(๑òωó๑)۶
我的博客:Xiao Xiangζั͡ޓއއ
很高兴见到大家,希望能够和大家一起交流学习,共同进步。
今天我们来学习const修饰指针,包括const修饰变量,const修饰指针变量;指针运算,包括指针±整数,指针-指针,指针的关系运算;野指针的介绍,三个成因,四个规避方法…
目录
- 一、const修饰指针
- 1.1 const修饰变量
- 1.2 const修饰指针变量
- 二、指针运算
- 2.1 指针+- 整数
- 2.2 指针-指针
- 2.3 指针的关系运算
- 三、野指针
- 3.1 野指针成因
- 3.1.1 指针未初始化
- 3.1.2 指针越界访问
- 3.1.3 指针指向的空间释放
- 3.2 如何规避野指针
- 3.2.1 指针初始化
- 3.2.2 小心指针越界
- 3.2.3 指针变量不再使用时,及时置NULL,指针使用之前检查有效性
- 3.2.4 避免返回局部变量的地址
- 四、结尾
一、const修饰指针
在 C 语言中,const是一个关键字,用于限定变量或对象为只读,即不允许通过程序修改它们的值。
1.1 const修饰变量
当const用于修饰变量时,表明该变量的值在初始化后不能被修改。例如:const int num = 10;,这里num被定义为一个常量整数,其值为 10,后续的代码中如果尝试对num进行赋值操作,如num = 20;,编译器会报错。
#include <stdio.h>
int main()
{int m = 0;m = 20;//m是可以修改的const int n = 0;n = 20;//n是不能被修改的return 0;
}
上述代码中n是不能被修改的,其实n本质是变量,只不过被const修饰后,在语法上加了限制,只要我们在代码中对n就行修改,就不符合语法规则,就报错,致使没法直接修改n。
但是如果我们绕过n,使用n的地址,去修改n就能做到了,虽然这样做是在打破语法规则。
像这样:
#inlcude<stdio.h>
int main()
{const int n = 0;printf("n = %d\n", n);int* p = &n;*p = 20;printf("n = %d\n", n);return 0;
}
我们可以看到这里确实修改了,但是我们之所以要用const去修饰n,就是为了不能被修改,如果p拿到n的地址就能修改n,这样就打破了const的限制,这是不合理的,所以应该让
p拿到n的地址也不能修改n,那接下来怎么做呢?
1.2 const修饰指针变量
⼀般来讲const修饰指针变量,可以放在的左边,也可以放在的右边,意义是不一样的。
int * p;//没有const修饰?
int const * p;//const 放在*的左边做修饰
int * const p;//const 放在*的右边做修饰
我们看下面代码,来分析具体分析一下:
#include <stdio.h>
//代码1 - 测试⽆const修饰的情况
void test1()
{int n = 10;int m = 20;int* p = &n;*p = 20;//ok?p = &m; //ok?
}
//代码2 - 测试const放在*的左边情况
void test2()
{int n = 10;int m = 20;const int* p = &n;*p = 20;//ok?p = &m; //ok?
}
//代码3 - 测试const放在*的右边情况
void test3()
{int n = 10;int m = 20;int* const p = &n;*p = 20; //ok?p = &m; //ok?
}
//代码4 - 测试*的左右两边都有const
void test4()
{int n = 10;int m = 20;int const* const p = &n;*p = 20; //ok?p = &m; //ok?
}
int main()
{//测试⽆const修饰的情况test1();//测试const放在*的左边情况test2();//测试const放在*的右边情况test3();//测试*的左右两边都有consttest4();return 0;
}
结论:const修饰指针变量的时候
• const如果放在 * 的左边,修饰的是指针指向的内容,保证指针指向的内容不能通过指针来改变。 但是指针变量本⾝的内容可变。
• const如果放在*的右边,修饰的是指针变量本身,保证了指针变量的内容不能修改,但是指针指向的内容,可以通过指针改变。
二、指针运算
指针的基本运算有三种,分别是:
• 指针± 整数
• 指针-指针
• 指针的关系运算
2.1 指针± 整数
因为数组在内存中是连续存放的,只要知道第一个元素的地址,顺藤摸瓜就能找到后面的所有元素。
创建一个数组
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
如果我们要从前面往后面寻找的话,我们可以这样:
#include <stdio.h>
//指针+- 整数
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int* p = &arr[0];int i = 0;int sz = sizeof(arr) / sizeof(arr[0]);for (i = 0; i < sz; i++){printf("%d ", *(p + i));//p+i 这⾥就是指针+整数}return 0;
}
如果我们要输入的话,也可以这样:
#include<stdio.h>
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]);//10int* p = &arr[0];for (i = 0; i < sz; i++){scanf("%d", p + i);}for (i = 0; i < sz; i++){printf("%d ", *(p + i));}return 0;
}
当然,我们也可以选择从后面往前面寻找:
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]);//10int* p = &arr[sz-1];for (i = 0; i < sz; i++){*(p - i) = i+1;}for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;
}
这里的 * ( p - 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]);//10int* p = &arr[sz - 1];for (i = 0; i < sz; i++){*p = i + 1;p--;}for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;
}
2.2 指针-指针
注意:
指针-指针的生活,两个指针一定是指向同一块区域的
指针-指针得的值是两个指针之间的元素个数的绝对值
#include<stdio.h>
int main()
{int arr[10] = { 0 };int n = &arr[0] - &arr[9];printf("%d\n", n);return 0;
}
像这样就不行:
int main()
{int arr[10] = { 0 };char ch[5] = {0};printf("%d\n", & arr[9] - &ch[0]);//errreturn 0;
}
再举个例子:
#include <string.h>
//strlen 是求字符串长度,统计的是字符串中\0之前的字符个数
int main()
{char arr[] = "abcdef";//a b c d e f \0//数组名其实是数组首元素的地址//arr == &arr[0]size_t len = strlen(arr);//6printf("%zd\n", len);return 0;
}
当然,我们也可以写一个具有strlen功能的函数:
第一种方法:
size_t my_strlen(char* str)
{size_t count = 0;while (*str != '\0'){count++;str++;}return count;
}int main()
{char arr[] = "abcdefghi";//a b c d e f \0//数组名其实是数组首元素的地址//arr == &arr[0]-- char*size_t len = my_strlen(arr);//6printf("%zd\n", len);return 0;
}
第二种方法,我们可以运用指针-指针:
size_t my_strlen(char* str)
{char* start = str;while (*str != '\0')str++;return str - start;//指针-指针
}
int main()
{char arr[] = "abcdefghi";//a b c d e f \0//数组名其实是数组首元素的地址//arr == &arr[0]-- char*size_t len = my_strlen(arr);//6printf("%zd\n", len);return 0;
}
2.3 指针的关系运算
//指针的关系运算
#include <stdio.h>
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int* p = &arr[0];int sz = sizeof(arr) / sizeof(arr[0]);while (p < arr + sz) //指针的⼤⼩⽐较{printf("%d ", *p);p++;}return 0;
}
三、野指针
野指针是指指向一个不确定、非法或已经释放的内存地址的指针。它不像正常指针那样指向一个有效的、可访问的内存位置,而是指向了一个未知或不应该访问的区域,这可能导致程序出现不可预测的行为和错误。
概念: 野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)
3.1 野指针成因
3.1.1 指针未初始化
#include <stdio.h>
int main()
{ int *p;//局部变量指针未初始化,默认为随机值*p = 20;return 0;
}
3.1.2 指针越界访问
#include <stdio.h>
int main()
{int arr[10] = { 0 };int* p = &arr[0];int i = 0;for (i = 0; i <= 11; i++){//当指针指向的范围超出数组arr的范围时,p就是野指针*(p++) = i;}return 0;
}
3.1.3 指针指向的空间释放
#include <stdio.h>
int* test()
{int n = 100;return &n;
}
int main()
{int* p = test();printf("%d\n", *p);return 0;
}
3.2 如何规避野指针
3.2.1 指针初始化
初始化指针:在定义指针时,始终给它赋一个合法的初始值,如NULL或指向一个有效的内存地址。
如果明确知道指针指向哪里就直接赋值地址,如果不知道指针应该指向哪里,可以给指针赋值NULL.
NULL 是C语言中定义的一个标识符常量,值是0,0也是地址,这个地址是无法使用的,读写该地址会报错。
#ifdef __cplusplus#define NULL 0#else#define NULL ((void *)0)#endif
初始化如下:
#include <stdio.h>
int main()
{int num = 10;int* p1 = #int* p2 = NULL;return 0;
}
3.2.2 小心指针越界
边界检查:在使用指针访问数组或其他有边界的内存区域时,要确保指针的访问在合法的范围内,避免越界操作。
一个程序向内存申请了哪些空间,通过指针也就只能访问哪些空间,不能超出范围访问,超出了就是越界访问。
3.2.3 指针变量不再使用时,及时置NULL,指针使用之前检查有效性
释放后置空:当释放动态分配的内存后,立即将指针设置为NULL,这样可以防止误操作。
当指针变量指向⼀块区域的时候,我们可以通过指针访问该区域,后期不再使⽤这个指针访问空间的时候,我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是:只要是NULL指针就不去访问, 同时使⽤指针之前可以判断指针是否为NULL。
我们可以把野指针想象成野狗,野狗放任不管是非常危险的,所以我们可以找⼀棵树把野狗拴起来,就相对安全了,给指针变量及时赋值为NULL,其实就类似把野狗栓起来,就是把野指针暂时管理起 来。
不过野狗即使拴起来我们也要绕着走,不能去挑逗野狗,有点危险;对于指针也是,在使用之前,我们也要判断是否为NULL,看看是不是被拴起来起来的野狗,如果是不能直接使用,如果不是我们再去使用。
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int* p = &arr[0];int i = 0;for (i = 0; i < 10; i++){*(p++) = i;}//此时p已经越界了,可以把p置为NULLp = NULL;//下次使⽤的时候,判断p不为NULL的时候再使⽤//...p = &arr[0];//重新让p获得地址if (p != NULL) //判断{//...}return 0;
}
3.2.4 避免返回局部变量的地址
如造成野指针的第3个例子,不要返回局部变量的地址。
四、结尾
这一课的内容就到这里了,下节课继续学习指针的其他一些知识
如果内容有什么问题的话欢迎指正,有什么问题也可以问我!