*pa = 0;// 把 a 内的 4 个字节的内容改成0
printf(“%p\n”,a);//0000 0000
return 0;
}
实例2
#include<stdio.h>
int main()
{
int a = 0x11223344;//内存形式为 44 33 22 11
char* pa = &a; //char* 字符指针类型，对其 指针变量（*pa）解引用可以访问 1字节
指针类型决定了指针解引用操作的时候，一次访问几个字节（访问内存的大小）
*pa = 0;
内存 存储形式为 小端 ： 44 33 22 11
由于 指针变量 pa 为 字符指针类型，对其 解引用 访问了 a 在内存中 低地址处 中 第 1 个字节的内容并改成0
即 00 33 22 11（低 ~ 高）
printf(“%p\n”, a);
打印是从高位开始打印
//11 22 33 00
return 0;
}
指针类型决定了，指针在加减整数的时候，跳过几个字节
实例1
#include<stdio.h>
int main()
{
int a = 10;
int* pa = &a;
char* pb = &a;
printf(“%p\n”, pa);//008FF730
printf(“%p\n”, pb);//008FF730
printf(“%p\n”, pa+1);//008FF734 int 类型加1，跳过4字节
printf(“%p\n”, pb+1);//008FF731 char 类型加1，跳过1个字节
//减法与之同理
return 0;
}
实例 2
#include<stdio.h>
int main()
{
int arr[10] = { 0 };// 40 byte
int* p = arr;//数组名是首元素地址 等价于 &arr[0] 首元素的地址为 int 类型，所以 需要 一个 整形指针变量（int* p） 来接收 数组首元素的地址
int i = 0;
for (i = 0; i < 10; i++)
{
*(p+i) = 1;
因为 对其 整形指针变量p 解引用，一次访问四个字节的内容，相当于 访问 整形数组 的 一个元素
而 i 是 一个整形，根据指针类型（指针类型 为 int ） + i 等价于 跳过 i 个 int 类型的数据
那么 该语句的作用： 是 把 整数数组的每个元素都初始化 为 1
printf("%d ",*(p+i));// 1 1 1 1 1 1 1 1 1
}
return 0;
}
内存使用更加灵活
实例 1
#include<stdio.h>
int main()
{
int arr[10] = { 0 };// 40 byte
char* p = arr;// 注意这里的 指针变量 p 为 字符指针类型，如果 对其 解引用 一次只能访问一个字节的内容
int i = 0;
for (i = 0; i < 40; i++)
{
*(p + i) = 1;
我们 以 16 进制来表示 数组 在内存中的存储情况
01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 。。。。。。
因为 *p 一次只能访问一个字节的内容，又因为 i 是 一个整形，根据指针类型（指针类型 为 char ） + i 等价于 跳过 i 个 char 类型的数据
通过观察，发现 这是一种 变相 修改 数组元素的值
printf("%d ",arr[i]);
01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
16843009 16843009 16843009 16843009 16843009 16843009 16843009 16843009
01 01 01 01 01 01 01 01
16843009 16843009
}
return 0;
}
==================================================================
指针 指向 的 位置，是不可预知的（随机的，不正确的，没有明确限制的）
1.指针未初始化
#include<stdio.h>
int main()
{
int* p;//没有初始化，不知道里面内容，里面放的是随机值
*p = 20;//通过p里面存的随机值作为地址，找到一块空间，这块空间，不属于当前程序
//造成了非法访问，程序崩溃，那么 p 就是野指针
return 0;
}
2.指针越界访问
#include<stdio.h>
int main()
{
int arr[10] = { 0 };//10个元素，下标是从0~9
int i = 0;
int* p = arr;// arr 这里 代表是 数组首元素地址，被 相对应类型指针变量 p 接收
for (i = 0; i <= 10; i++)//循环11次（i == 0 也是会进入循环体的），，访问第11个元素，而它只有10个元素，越界访问。造成程序崩溃
{
*p = i;
p++;
}
return 0;
}
3.当一个指针 指向的空间 被释放了,或者 指针 指向的空间 被释放了，还有人在使用它。
#include<stdio.h>
int* test()
{
int a = 10;
return &a;
局部变量的生命周期 ，进入这个范围（a 的范围 是 int* test（）这个函数范围）到出这个范围。
它的地址用完就要返还电脑（栈空间，而且栈空间的使用是先使用高地址，再使用低地址），此时此地址已不属于我们，但是 它把这个地址当做返回值，返回给int* p。
}
注意！
虽然这个地址还给电脑，但是里面的内容很可能没改。也就意味着 内容可能还在，但不属于不属于我们，
//举个例子：宾馆开房，你住的期间，是你的，房屋里面摆放是按照你的要求布置的，
//等你退房之后，房间使用权你就没有了，你再使用就是违法的。
//另外等你退房之后，房间并没有改变摆设，等下一个人来住的时候，就按别人的要求摆放，
int main()
{
int* p = test();// test返回的地址，被 *p记住了（此地址不属于当前程序）
printf(“hehe\n”);// 打印 hehe 需要向内存申请空间，也就是说 test 函数 还给xt的内存，被占用了，
// 根据例子 hehe 就是 该房间现在的使用者
printf(“%d\n”, *p);//所以这时候 *p 就属于非法访问
//本来上表达式按逻辑来说是随机值，但上表达式a的值还是10；
//是因为这个地址还给电脑，但没改。所以内容还在，所以访问还是10，但不属于不属于我们，
//如果在输出前面加一个函数或者其他的，向栈里面申请内存，把test还给电脑的内存，给占用了。
//那么*p的输出是无法确定的
return 0;
}
栈空间，且使用是先使用高地址，再低地址
#include<stdio.h>
int main()
{
int a = 10;
int b = 20;
printf(“%p\n”,&a);//0113F8 D8
printf(“%p\n”, &b); //0113F8 CC
在十六进制中 D 比 C要大，也就意味着 a 地址 比 b 的地址要大
//由此可见:栈空间，是先使用高地址，再低地址
return 0;
}
避免造成野指针
1.指针初始化
2.指针指向空间释放级设置NULL
3.使用地址之前检查有效性
4.避免返回局部变量的地址
5.小心指针越界
实例1
#include<stdio.h>
int main()
{
int a = 10;//明确地初始化
int* p = &a;//确定指向
int* p2 = NULL;//不知道一个指针当前应该指向哪里时，初始化 NULL （空指针； 0的另一种写法）
// 初始化 NULL，相当于标记状态，这个指针还没有指向任何对象 ，要注意了
//如果不初始化，就不知道它指向那块空间。
举个例子：指针不初始化相当于 街上有一只没有主人的野狗，可能会伤人。
指针初始化 NULL，就相当于把它拴在一颗树底下（这棵树，就相当于一个危险标记），防止伤害到人，
当然前提是你不去接近，所以我们只需绕着走，就可以避免危险，
int* p2 = NULL; 该语句 相当于 指针初始化 NULL，标记它是野指针，不要去调用它
if (p2 != NULL)// 意思就是 如果 我们 没有将 P2 置为空指针，就执行 下面的 if 语句
*p2 = 100;
这就相当于你非要去那棵树底下方便，它肯定就会伤害你（这么挑衅的行为，它不咬你才怪）；
所以我们去尿尿时，需要提前看一下树底下有没有狗，
即 该树下没有狗，意味着我们可以去方便 （该指针初始化了，且是一个有效地址，我们再去使用它）
// p2是一个空指针，空指针是0，0也是地址，0指向的地址是不可使用的
// *p2 = 100; 该表达式是错误的，属于非法操作
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]);
int* p = arr;
for (i = 0; i < sz; i++)
{
printf("%d ",*(p+i));// 1 2 3 4 5 6 7 8 9 10
}
printf(“\n”);
for (i = sz-1; i >= 0; i–)
{
printf("%d ", *(p + i));//10 9 8 7 6 5 4 3 2 1
}
return 0;
}
由 该程序我们发现， 数组名（其实就一个指针【地址】），当我们加上一个 整数时，它根据 它 自身的数据类型来判断
就拿上面的程序来说， 数组的类型为int 类型，当我们 用 arr（首元素地址）+ i（i是一个整数） 时，
整数 i 会 根据 数组 的类型，来进行判断 一次 跳过 i 个 为 int 类型的数据
附图
实例1
#include<stdio.h>
int main()
{
char ch[5] = { 0 };
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
printf(“%d\n”,&arr[9] - &arr[0]);//指针 - 指针 得到是指针和指针之间（ &arr[0]~&arr[9] //左开右闭区间）的元素的个数
// 输出为 9
printf(“%d\n”, &arr[9] - &ch[0]);//这种写法error，因为指针减指针，两者必须是同一块空间里的。
return 0;
}
附图
实例 2
#include<stdio.h>
int my_strlen(char* arr)
{
char* start = arr;
char* end = arr;
while (*end != ‘\0’)//循环结束后 end == ‘\0’ == arr[3]
{
end++;
}
return end - start;//arr[3] - arr[0] 左开右闭
// 第四个元素减去 第一个元素 == 3
}
int main()
{
char arr[] = “bit”;
int len = my_strlen(arr);
printf(“%d\n”,len);
return 0;
}
#define N_VALLUES 5 // 在程序中 遇见 N_VALLUES 在预编译期间 会被替换成 5
#include<stdio.h>
int main()
{
float values[N_VALLUES];
float *vp;
// 1.correct（正确写法）
for (vp = &values[ N_VALLUES ] vp > &values[0]/指针是可以比较大小的/ ; /省略了/ )
// 等价于 for (vp = &values[5] vp > &values[0] ; )
在 C语言标准中 允许指向 数组元素 的 指针 与 指向数组 最后一个元素 后面的那个内存位置 的 指针比较;
而且只是比较地址，并没有对其解引用，所以构不成越界访问
有人可能会说 &values[ N_VALLUES ] 不是有 [] 操作符吗？不是应该对其解引用，既然解引用，就会造成越界访问
但是其实 & 把 [] 给抵消了。
例如： &arr[3] == & *(arr+3) == arr + 3 等价于 首元素地址加上 3，还会一个地址
{
*–vp = 0;// for 循环条件 的 省略部分在这里
}
// 2. error（错误写法）
for (vp = &values[N_VALLUES-1]; vp >= &values[0];vp–)//C语言的标准，并不保证它能运行
//不允许与指向第一个元素之前的那个内存位置进行比较
C语言标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较;
但不允许与指向第一个元素之前的那个内存位置进行比较
{
*vp = 0;
}
return 0;
}
附图
====================================================================
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf(“%p\n”,arr);//打印首元素地址
printf(“%p\n”, &arr);//打印数组的起始地址【数组的地址】
printf(“%p\n”, &arr[0]);//打印首元素地址
//在绝大部分情况，数组名表示是首元素地址
//但有两种情况例外
// &数组名，arr代表的是整个数组的起始地址。
//sizeof(数组名)，arr代表的是整个数组，sizeof计算的是整个数组的大小，单位byte
printf(“------------------------\n”);
printf(“%p\n”, &arr[0]); // 00F3F8E8 首地址
printf(“%p\n”, &arr[0] + 1);//00F3F8EC加了4字节，因为数组元素类型 int
printf(“%p\n”, &arr);// 00F3F8E8 数组的起始地址【数组的地址】
printf(“%p\n”, &arr + 1);// 00F3F910 加了40字节（2 * pow（16，1） + 8 * pow（16,0） == 8 + 32 = 40），
//即跳过一个数组
你会发现 数组的地址 和 数组首元素地址 是一样的 ，但是意义却不一样， 我们通过 指针加减整数 可以发现 两者的不同
return 0;
}
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
int* p = arr;// 指针变量p 存的是 arr首地址
int i = 0;
for (i = 0; i < 10; i++)
{
printf(“%p…%p\n”,p+i,&arr[i]);// 两种写法是等价的
p+i 是根据数组首元素地址 加减 整数 i（其实可以说是下标 i），跳过 i 个 int类型的额元素，来找到我们想要打印的元素地址
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
int* p = arr;// 指针变量p 存的是 arr首地址
int i = 0;
for (i = 0; i < 10; i++)
{
printf(“%p…%p\n”,p+i,&arr[i]);// 两种写法是等价的
p+i 是根据数组首元素地址 加减 整数 i（其实可以说是下标 i），跳过 i 个 int类型的额元素，来找到我们想要打印的元素地址
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-NaxflxYB-1715867797811)]
[外链图片转存中…(img-35M7MfNT-1715867797812)]
[外链图片转存中…(img-Y8AMCypw-1715867797812)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
