pointer（指针）- 重置版

#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;

}

#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;

}

#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;

}

#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;

}

#include<stdio.h>

int main()

{

int* p;//没有初始化，不知道里面内容，里面放的是随机值

*p = 20;//通过p里面存的随机值作为地址，找到一块空间，这块空间，不属于当前程序

//造成了非法访问，程序崩溃，那么 p 就是野指针

return 0;

}

#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;

}

#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.小心指针越界

#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 类型的数据

#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;

}

#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;

}