指针（1）

1. 内存

        我们的计算机CPU在处理数据时，需要在内存中读取数据。为了高效地管理内存空间，就将内存划分为一个个的内存单元，每个内存单元的大小取一个字节。每个字节中能放8个比特位，每个内存单元都有一个编号，有了这个内存单元的编号，CPU就可以快速找到一个内存空间。（枯燥乏味的概念，真让人头大）

 内存单元的编号也被称为地址。C语言中把地址叫做指针，可以理解为：

                                          内存单元的编号==地址==指针

        我们要理解的一点是计算机CPU和内存之间有大量数据交换，两者便必须用“线”连接起来，其中有数据总线，控制总线，地址总线等，但现在我们先来关注一组线——地址总线。

        学过一点计算机知识的读者可知：在32/64位机器上有32/64根地址总线，每根线都只有两态，表示0,1【电脉冲有无】，则一根线可表示两种含义，32/64根地址主线表示2^32/2^64每一种含义代表一个地址。

        地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据再通过数据总线传入CPU内寄存器。

2. 指针变量和地址

2.1 取地址操作符（&）

在C语言中创建变量其实就是向内存申请空间，一个整型变量可向内存申请4个字节，每个字节都有地址，那么如何得到这个地址呢？这里就需要用到&（取地址操作符），如：

        这里采用的是VS2022 32位环境下（64位环境下打印地址长度过长）打印的地址，%p用来打印地址，&a取出的是a所占4个字节中地址较小的字节的地址。

2.2 指针变量和解引用操作符（*）

2.2.1 指针变量

        我们通过取地址操作符（&）拿到的地址是一个数值，如：00EDFC60，这个数值也需要存储起来，方便后续使用，那我们把这样的地址值存放在哪里？答案是：指针变量中。

比如：

1. #include<stdio.h>
2. int main()
3. {
4.    int a = 10;
5.    int* pa = &a;
6. 
7.    return 0;
8. }

指针变量也是一种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。

2.2.2 指针类型

在上述代码中pa的类型是int* ，

1. int a = 10;
2. int* pa = &a;

        可知：pa左边写的是 int* , * 是在说明pa是指针变量，而前面的 int 是在说明pa指向的是整型（int）类型的对象。 

        同理可知：char类型变量应放在 char* 指针变量中。

2.2.3 解引用操作符

                我们将地址保存起来就是为了使用，那么我们应该怎么使用呢？

        在C语言中，我们拿到了地址（指针），就可以通过地址（指针）找到其指向的对象，现在我们来学习另一个操作符，解引用操作符（*）。

1. #include<stdio.h>
2. int main()
3. {
4.    int a =100;
5.    int* pa = &a;
6.    *pa = 0;
7.    return 0;
8. }

         上面代码第6行就使用了解引用操作符，*pa的意思就是通过pa中存放的地址，找到指向的空间，*pa其实就是a变量了；所以*pa=0，这个操作符是把a改成了0；

        这里把a改成0的操作提供了另一种方法，写代码更灵活。

2.3 指针变量的大小

        前文提到，32位机器假设有32根地址总线，每根地址总线出来的电信号转换成数字信号后是1或0，那我们把32位地址总线产生的2进制序列当作一个地址，那么一个地址就是32个比特位，需要4个字节才能存储。

        如果指针变量是用来存放地址的，那么指针变量大小就是4个字节的空间才可以。

        同理64位机器，假设有64根地址线，一个地址就是64个二进制位组成的二进制序列，存储起来就需要8个字节的空间，指针变量的大小就是8个字节。

X86环境下 

X64环境下

结论：

• 32位平台下地址是32个比特位，指针变量是4个字节
• 64位平台下地址是64个比特位，指针变量是8个字节
• 注意指针变量的大小跟类型是无关的，只要指针类型的变量在相同的平台下，大小都是相同的

3. 指针类型的意义 

3.1 指针的解引用

        通过调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第一个字节改为0.

结论：

        指针类型决定了对指针解引用的时候有多大的权限（一次操作几个字节）。

比如：char* 的指针解引用就只能访问一个字节，而 int* 的指针解引用就能访问四个字节。

4.2 void* 指针

        在指针类型中有一种特殊的类型 void* 类型，可以理解为无具体类型的指针（或者叫泛指指针），这种类型的指针可以用来接受任意类型地址。但也有局限性，void* 类型的指针不能直接进行指针的+-整数和解引用的运算。

举例：

1. #include<stdio.h>
2, 
3. int main()
4. {
5.   int a = 10;
6.   int* pa = &a;
7.   char* pc = &a;
8.   return 0;
9. }

        把int类型的变量的地址赋值给一个char*类型的指针变量，编译器会由于类型不兼容而报错。但是用void*则不会有这样的问题。

        void*类型的指针是可以接受不同类型的地址，但是无法直接进行指针运算。

        一般void*类型的指针是使用在函数参数部分，用来接收不同数据类型的地址，这样的设计可以实现泛型编程的效果。使得一个函数 来处理多种类型的数据。

4.3 指针运算

4.3.1 指针+-整数

1. #include<stdio.h>
2. int main()
3. {
4.    int n = 10;
5.    char* pc = (char*)&n;
6.    int* pi = &n;
7.    printf("%p\n",&n);
8.    printf("%p\n",pc);
9.    printf("%p\n",pc+1);
10.   printf("%p\n",pi);
11.   printf("%p\n",pi+1);
12.   return 0;
13. }

        可以看出的是：char* 类型的指针变量+1跳过一个字节，int* 类型的指针变量+1跳过了四个字节。这就是指针变量的类型带来的变化。指针+1，其实就是跳过一个指针指向的元素。指针可以+1，那也可以-1.

结论： 指针的类型决定了指针向前或者向后走一步有多大（距离）。

        因为数组在内存中是连续存放的，只要知道第一个元素的地址，顺藤摸瓜就能找到后面的所有元素。

1.  #include<stdio.h>
2.  //指针+-整数
3.  int main()
4.  {
5.     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
6.     int* p = &arr[0];
7.     int i = 0;
8.     int sz = sizeof(arr)/sizeof(arr[0]);
9.     for(i = 0;i < sz; i++)
10.    {
11.       printf("%d ",*(p+i));
12.    }
13.    return 0;
14.  }

4.3.2 指针-指针

1.  #include<stdio.h>
2.  int my_strlen(char *s)
3.  {
4.      char* p = s;
5.      while(*p != '\0')
6.           p++;
7.      return 0;
8.  }
9.  int main()
10. {
11.    printf("%d\n",my_srlen("abc"));
12.    return 0;
13. }

4.3.3 指针的关系运算

1.  #include<stdio.h>
2.  int main()
3.  {
4.     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
5.     int *p = &arr[0];
6.     int i =0;
7.     int sz = sizeof(arr)/sizeof(arr[0]);
8.     while(p<arr+sz)
9.     {
10.       printf("%d ",*p);
11.       p++;
12.    }
13.    return 0;
14. }

5. 野指针

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

5.1 野指针成因

5.1.1 指针未初始化

1. #include<stdio.h>
2. int main()
3. {
4.    int *p;
5.    *p = 20;
6.    return 0;
7. }

在VS2022上演示如下：

        可以看出程序无法执行，报错了！而在小熊猫C++或一些其他的软件上可能不报错，但产生的数值往往让你意想不到。 

5.1.2 指针越界访问

1.  #include<stdio.h>
2.  int main()
3.  {
4.     int arr[10] = {0};
5.     int* p = &arr[0];
6.     int i = 0;
7.     for(i = 0;i<=11;i++)
8.     {
9.        *(p++) = i;
10.    }
11.    return 0;
12.  }

以上代码在VS2022上执行会显示以下错误：

        显示大概意思就是变量“arr”周围的堆栈已损坏上面代码“arr”数组就只有10个数据，但在访问时却访问了11个，这又怎能不报错呢？

5.1.3 指针指向的空间释放

1.  #include<stdio.h>
2.  int*test()
3.  {
4.     int n =100;
5.     return 0;
6.  }
7. 
8.  int main()
10. {
11.    int*p = test();
12.    printf("%d\n",*p);
13.    return 0;
14. }  

又又报错了！！！

上面显示读取访问权限冲突 ，函数调用后其所创建的地址就会消失，故而引发报错。

5.2 如何规避野指针

5.2.1 指针初始化

        如果明确知道指针指向哪里就直接赋值地址，如果不知道指针指向哪里，可以给指针赋值NULL。NULL是C语言中定义的一个标识符常量，值是0,0也是地址，这个地址是无法使用的，读写改地址会报错。

初始化如下：

1. #include<stdio.h>
2. int main()
3. {
4.    int num = 10;
5.    int* p1 = &num;
6.    int* p2 = NULL;
7.    return 0;
8. }

5.2.2 小心指针越界

        一个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超过范围访问，超出了就是越界访问。

5.2.3  指针变量不再使用时，及时置NULL，指针使用之前检查有效性

        当指针变量指向一块区域时，我们可以通过指针访问该区域，后期不再使用这个指针的时候，我们可以把该指针置为NULL。因为约定俗成的一个规则就是：只要是NULL指针就不再访问，同时使用指针之前可以判断指针是否为NULL。

5.2.4 避免返回局部变量的地址

        如造成野指针的第3个例子，不要返回局部变量的地址。