玩透指针系列——茅塞顿开，原来这就是指针！

Posted 2021-09-05 Chaser Feng

文章目录

• 1.指针是什么
• 2.指针和指针类型
• 3.野指针
• • 3.1.野指针的成因
  • 3.2.如何规避野指针
• 4.指针运算
• • 4.1. 指针 +/- 整数
  • 4.2. 指针 - 指针
  • 4.3 指针的关系运算
• 5. 指针和数组
• 6.二级指针

1.指针是什么

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

可以这样理解：
内存被细分为一个个大小为一个字节的内存单元（即一个内存单位为一个字节），每一个内存单元都有自己对应的地址。
图解如下

所以指针是变量，用来存放内存内存单元的地址编号(存放在指针中的值都被当成地址处理)
对应代码：

#include <stdio.h>
int main()
{
int a = 10; //在内存中开辟一块空间
int *p = &a; //这里我们对变量a，取出它的地址，可以使用&操作符
//将a的地址存放在p变量中，p就是一个之指针变量
return 0;
}

那么一个指针的大小是多少呢？
C语言规定：
针的大小在32位平台是4个字节，在64位平台是8个字节

2.指针和指针类型

我们知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
准确的说：sure ！当然是有的。

指针的定义方式是： type + *
例如：
char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。

指针类型有什么意义呢？
看如下代码运行结果：

当我们观察内存时会发现，指针 p 的类型为 int * 时，*p=0 的结果是四个字节全部变为0；而同样的数字，当指针 pa 的类型为 char * 时，改变使 *pa=0,可以看出内存中只改变了一个字节为0；
所以，指针类型决定了指针解引用的权限有多大。

由上图我们可以看出，当指针p为 int* 类型时，p+1 的地址就加上了4个的字节的单位；而当类型为char* 的指针 pa+1时，相对pa只加上了1个字节的单位。
所以，指针的类型还决定了指针走一步，能走多远（步长）；即当指针类型为 double* 时，走一步就跳过了8个字节的单位长度（走 n 步就跳过了 n x 8 个字节的长度），其他类型以此类推。

总结
指针类型的意义：
1.指针类型决定了，指针解引用的权限有多大
2.指针类型决定了，指针走一步，能走多远

注意一点：指针类型的意义与指针大小没联系，无论指针为什么类型，它的大小始终只为 4 / 8 个字节

应用：

因为p 为int* 型指针，p+i 相当于跳过 int 型大小的字节个数（即4个字节），而数组arr为整型数组，每个元素为 int 型，所以当循环结束后 arr 中的每个元素都变成了1。

此时的 p 为 char* 型，p+i 就相当于跳过 char 型大小的字节个数（即1个字节），arr 中每个元素为 int 型，所以每个元素占 4 个字节的大小，当循环结束后，指针p就总共跳过了10个字节，即将10个字节赋值为1，如上图所示。

3.野指针

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

3.1.野指针的成因

野指针的成因主要有三种情况

1.指针未初始化

#include <stdio.h>
int main()
{ 
 int *p;//局部变量指针未初始化，默认为随机值
     *p = 20;
 return 0;
}

导致结果：

2.指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;
   }
    return 0;
}

即当指针指向的范围超出数组arr的范围时，p就是野指针。

3.指针指向的空间释放
即当一个指针指向的空间被释放后，在次使用这个指针时，此时这个指针就成为了野指针。

由上图可以看出，当a为局部变量在函数内部时，在主函数中再取出a的地址就会发生错误，原因是当函数用完后函数中的变量就会自动销毁，当再取出函数中变量的地址时就会造成野指针。

那么我们平时写程序时又该如何规避野指针呢？

3.2.如何规避野指针

这里给出几点建议：

1. 指针初始化
   当不知道将指针初始化为何值时，就初始化为NULL(空指针)

2. 小心指针越界

3. 指针指向空间释放及时置NULL

4. 避免返回局部变量的地址
   (因为局部变量在使用后就会被销毁，若在函数中作为返回值被使用就相当于使用了野指针)

5. 指针使用之前检查有效性（即使用前为初始化为NULL,使用时先判断是否为NULL,若为，则不能使用，不为NULL才能使用这块地址空间）
   如：
   #include <stdio.h>
   int main()
   {
   int *p = NULL;
   //…
   int a = 10;
   p = &a;
   if(p != NULL)
   {
   *p = 20;
   }
   return 0;
   }

4.指针运算

4.1. 指针 +/- 整数

如下情形：

#include<stdio.h>
int main()
{
	int arr[5] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
	}
	return 0;
}

前面提到过，指针 + / - 整数 就相当于向前 / 向后移动。

4.2. 指针 - 指针

指针 - 指针的值是是两个指针之间的元素个数
前提：两个指针指向的是同一块空间

int my_strlen(char* p)
{
	char* pc = p;
	while (*p != '\\0')
		p++;
	return p - pc;
}

其中 my_strle n函数为模拟的实现求字符串长度的函数，函数通过求得字符串的首地址和尾地址，而后相减求得字符串的长度

4.3 指针的关系运算

指针的关系运算，即指针之间比较大小。
例如：我们如果要将一个数组中的元素全部置0，可以有两种方法
法1.由前向后置0法

#include<stdio.h>
int main()
{
	int arr[5] = { 1, 2, 3, 4, 5 };
	int* p = &arr[0];
	for (p = &arr[0]; p <= &arr[4]; p++)
	{
		*p = 0;
	}
	return 0;
}

即当最后一个 p > arr [ 4 ] 时结束循环

法2.由后向前置0法

#include<stdio.h>
int main()
{
	int arr[5] = { 1, 2, 3, 4, 5 };
	int* p = &arr[4];
	for (p = &arr[4]; p >= &arr[0]; p--)
	{
		*p = 0;
	}
	return 0;
}

即当最后指针 p < arr [ 0 ] 时，循环结束

以上两种方法都利用了指针大小的比较，但通常情况下，我们应该避免使用第二种方法，原因在于
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行较。

即指向元素的指针能与>arr[4] 的部分的地址进行比较而不能与<arr[0]进行比较。

5. 指针和数组

首先弄明白，数组名是什么？

#include <stdio.h>
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    printf("%p\\n", arr);
    printf("%p\\n", &arr[0]);
    return 0;
}

我们可以看出，arr与arr[0]的地址一样
结论：数组名表示的是数组首元素的地址。
那么我们就可以通过将数组的数组名存放在一个指针中，进而通过指针就可以对整个数组进行操作
例如：

#include <stdio.h>
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,0};
    int *p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr)/sizeof(arr[0]);
    int i=0;
    for(i=0; i<sz; i++)
   {
        printf("&arr[%d] = %p   <====> p+%d = %p\\n", i, &arr[i], i, p+i);
   }
    return 0;
}

运行结果

所以可见 p + i 其实计算的是数组 arr 下标为 i 的地址
那我们就可以直接通过指针来访问数组。
如下：

int main()
{
 int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 int *p = arr; //指针存放数组首元素的地址
 int sz = sizeof(arr) / sizeof(arr[0]);
 int i = 0;
 for (i = 0; i<sz; i++)
 {
 printf("%d ", *(p + i));
 }
 return 0;
}

即通过 p + i 来实现对数组的访问。

延伸：

int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int* p=arr;
}

对于以上代码，数组名和指针之间可做如下操作：
因为arr就是首元素地址，指针p=arr,就相当于两者对等，所以可以做如下转换：
arr [ 2 ] = *( arr + 2) = *( p + 2 ) = *( 2 + p ) = *( 2 + arr ) =2 [ arr ]
以上等式均成立，除此之外，arr [ 2 ] = p [ 2 ] = 2 [ p ]， 但这种形式很少见

6.二级指针

我们知道，指针变量是用于存放地址的变量。但是指针变量也是变量，是变量就有地址，那么存放指针变量的地址的变量是什么呢？
其实，存放普通变量的地址的指针叫一级指针，存放一级指针变量的地址的指针叫二级指针，存放二级指针变量地址的指针叫三级指针…以此类推 n 级指针。
例如：

#include<stdio.h>
int main()
{
	int a = 10;
	int* p = &a;
	int** pa = &p;
	return 0;
}

这里a为普通变量，p为一级指针变量，pa 就为二级指针变量。此时，想要得到a 的值就有两种方法：
1.对一级指针p解引用， 即 *p 。
2.对二级指针 pa 进行一次解引用操作即可得到 p 的值，而p的值就是 a 的地址，所以再对 p 进行一次解引用操作即可得到 a 的值，也就是对二级指针 pa 进行两次解引用操作即可得到a的值，即 ** pa 。

OK,初级指针的讲解就到这。