9.0、C语言——初识指针

9.0、C语言——初识指针(1)

指针是什么？

        在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，他的值直接指向（point to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以他为地址的 内存单元

        总结：指针是一个变量，而这个变量存放的内容是地址，所以可以说地址就是指针，指针就是地址  

那这里的问题是：
        1、一个内存单元是多大？
        2、如何编址？

        经过计算和权衡我们发现一个字节给一个对应的内存单元是比较合适的

        对于 32 位的机器，假设有 32 根地址线，那么每根地址线在寻址的时候产生一个电信号 -> 正电 / 负电（ 1 或 0 ）；
        那么 32 根地址线就会产生 32 位的二进制数，64位同理......

指针所占空间大小：

        在32位的机器上，每个地址就是一个32位的二进制数，并且可以产生2^32个地址，每个地址占 4 字节所以一个指针的大小就是 4 字节；
        同理64位的机器计算方法相同......

总结：
        1、指针是用来存放地址的，地址是地址空间唯一的标识
        2、指针的大小在 32 位平台是 4 个字节，在64位平台是 8 个字节

指针类型：

指针变量有很多种类型，比如： int* 、 char* 、 float* 、 double*

但是我们会发现无论是哪一种类型存放的地址都是 32 位的地址【这里假设是32位的计算机】，也就是说 ->

int main() {
    int a = 10; 
    char* pa = &a; 
    printf("pa = %p",pa);
    return 0;
}

        这段代码不会报错，因为无论你是什么类型的数据，你的地址都是 32 位的【这里假设计算机是 32 位操作系统】，所以都可以存放，那么这时候我们就会想了既然都一样为什么还要区分不同的指针类型呢？统 一 一 个不就好了~

        来解释一下为什么要区分不同的指针变量 -->
有以下两点原因，先来看看以下代码：

int main() {
 
    //代码块1
        int a = 0x11223344;
        int* pa = &a;
        *pa = 0;
        printf("a = %d",a);
    //代码块2
        int b = 0x1122334;
        char* pb = &b
        *pb = 0;
        printf("b = %d",b);
 
    return 0;
}

        代码块1中，首先定义了一个 16 进制的变量 a = 0x11223344 ， 这是为了将 int 数据类型的 4 个字节内存空间填满，然后通过取地址 a 的方式将 a 的值改变为0；
        代码块2中，同样定义了一个 16进制的变量 b =  0x11223344 ， 然后通过取地址 b 的方式将 b 的值改变为0【不同的是 -> 指针变量不是 int* 而是 char* 】；

        最终打印出来的结果 a 的值修改成功了，但是 b 的值没有修改成功，
        我的理解是：假设int a = 10; 如果我们取地址 int* pa = &a,那么这个指针变量pa就是存储 a 变量的第一个内存空间地址，然后由于我们的我们声明指针变量的时候是 int* 类型所以他会从该地址开始向下访问四个内存空间的地址，所以能够操作4个内存空间；
        但是如果我们用 char* pb 去声明指针变量，那么只能从该地址开始向下访问一个内存空间的地址，也就是只能操作一个内存空间，导致最后修改值失败~

原因之一 -> 总结：指针类型决定了指针进行 解引用操作 的时候，能访问空间的大小 ->
具体指的就是:
        int* p ，*p 能够访问 4 个字节
        char* p ，*p 能够访问 1 个字节
        double* p，*p 能够访问 8 个字节
......其它指针类型同理

原因之二 ->指针类型还决定了 -> 指针+1 会向后跳几个字节:

例如：

int main() {
    int a = 10;
    int* pa = &a;
    char* pb = &a;
    printf("%p",pa + 1);
    printf("%p",pb + 1);
    return 0;
}

        输出结果后可以发现，pa向后调了4个字节【因为他是int*类型指针】，而pb只向后跳了1个字节【因为pb是char*类型指针】

总结：
        指针类型决定了：指针向前或向后走一步走多远（指针的步长）
        int* p;           p + 1 --> 4 字节
        char* p;        p + 1 --> 1 字节
        double* p     p + 1 --> 8 字节

再给大家举个例子，代码如下所示：

int main() {
	int a = 1;
	char* p = &a;
	*(p + 1) = 1;
	printf("a = %d",a);
	return 0;
}

        int a = 1; 【定义一个整型变量a = 1】
        char* p = &a; 【定义一个 char* 类型的指针变量 p】
        *(p + 1) = 1; 【地址p 加 1之后解引用符 = 1，其实就是在变量 a 的第二个字节的内存空间中，修改值为 1 】
        printf("a = %d",a); 【输出结果为 a = 257，将第二个字节内存空间的值改为 1 之后会得到00000000 00000000 00000001 00000001 将其转换为十进制后得到的数字为 257 】

野指针：

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

那什么原因会导致野指针呢？

        原因一：首先明白一个原则 -> 局部变量如果不初始化，那么该变量默认是随机值，比如 int a; 那么 int* p; 也是局部指针变量，如果不初始化就会给指针 p 一个随机值。

        那么这种写法是非法的很危险，千万不要使用这种写法~

        原因二：在数组越界、内存越界的时候也会出现野指针，如下代码：

int main() {
	int arr[10] = { 0 };
	int* p = arr;
	for (int i = 0; i < 15; i++) {
		p++;
	}
}

        上述代码中 -> 数组 arr 只有 10 块内存空间，当我们的 for 循环中 p 一直 ++ ，当 p 超出 arr 数组管理的范围之后，就会被称为野指针

        原因三：指针指向的空间释放，如下代码：

int* test() {
	int a = 10;
	printf("&a = %p\n",&a);
	return &a;
}
int main() {
	int* p = test();
	printf(" p = %p",p);
	return 0;
}

        test()函数中，定义了一个变量int a = 10; 然后将 a 的地址返回 return &a;
        main()函数中，int* p 指针变量接收 test() 函数返回的地址【但是注意：这时候由于变量 a 是局部变量 -> 已经被销毁了，a 的内存空间已经被系统释放了】，所以这时候指针变量 p 指向的其实是一块已经被释放的内存块；
        那么这就是第三种产生野指针的原因~
       

那么如何规避野指针呢？

        1、指针初始化
        2、小心指针越界
        3、指针指向空间释放及时置NULL【当我们不知道该给指针赋什么值的时候 -> int* p = NULL;】
        4、指针使用之前检查有效性【例如：if(p != NULL){printf("该指针为有效指针~");}】