【C语言】指针篇，不会的一定要看，指针没有想象的那么难，我们一起攻克它

痛定思痛。 2023-09-27 16:50 89阅读 0赞

**目录**

1、指针是什么？

2、指针和指针类型

2.1指针的解引用

2.3 指针+-整数

3、野指针

3.1野指针的成因

3.1.1.指针未初始化

3.12.指针越界访问

3.1.3指针指向的空间释放

3.2 如何规避野指针

4、指针运算

4.1 指针 +- 整数

4.2 指针 - 指针

举例：求字符串长度

4.3 指针的运算关系

5、指针和数组

6、二级指针

7、指针数组

引申：

指针数组使用

引申：

--------------------

指针在学习的时候总是感觉很难，思路很乱，那是因为我们没有把知识梳理出来。本篇就是带大家把指针基础的知识进行梳理一遍，其实没有那么难，我们不妨来看看这篇文章。话不多说，上车。

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*正文开始\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

## 1、指针是什么？ ##

**指针理解的 2 个要点：**

1.指针是内存中一个最小单元的编号，也就是地址；

2.平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量。

**总结：指针就是地址，口语中说的指针通常指的是指针变量。**

**指针变量**

我们可以通过 & （取地址操作符）取出变量的内存起始地址，把地址可以存放到一个变量中，这个变量就是指针变量。

int main()
    {
    	int a = 10;
    	int* pa = &a;//&a - 得到的是a的地址（指针），pa是指针变量
    				//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在pa变量中，
    				//pa就是一个指针变量
        pa = 10;//pa是指针变量，因此不管你给赋什么值，都当作地址处理
    	return 0;
    }

> 指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
> 
> 一个小的单元一个字节最为合适。
> 
> 对于32位的机器 - 32根地址线 - 地址线寻址产生高低电平（1/0）
> 
> 产生的地址就会是：
> 
> 00000000 00000000 00000000 00000000 -- 4个字节
> 
> 00000000 00000000 00000000 00000001
> 
> ……
> 
> 11111111 11111111 11111111 11111111
> 
> 这里就有2的32次方个地址。
> 
> 2\*10^32byte == 4G
> 
> **这就让我们明白了：**
> 
> **32位机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。**
> 
> **64位机器上，地址是64个0或者1组成二进制序列，那地址就得用8个字节的空间来存储，所以一个指针变量的大小就应该是8个字节。**
> 
> **总结：**
> 
> 指针变量是用来存放地址的，地址是唯一标识一个内存单元的。
> 
> **指针的大小在32位平台上是4个字节，在64位机器上是8个字节。**

## 2、指针和指针类型 ##

这里我们再讨论一下：指针的类型

我们都知道，变量有不同的类型，整型，浮点型等。那指针有没有类型呢？

准确的说：有的。

**我们先来看指针的大小：**

int main()
    {
    	printf("%u\n", sizeof(int*));//%u打印的是无符号数
    	printf("%u\n", sizeof(char*));
    	printf("%u\n", sizeof(short*));
    	return 0;
    }

![59a9509d13f1f597529677e9ba4ad09c.png][]

**因此我们可以知道：****无论什么类型的指针大小都是 4/8 个字节（32/64位平台）。**

指针类型决定了指针向前或者向后走一步走的距离 -- 单位是字节

指针的定义方式是： type + \* 。

其实：

char\* 类型的指针是为了存放 char 类型变量的地址。

short\* 类型的指针是为了存放 short 类型变量的地址。

int\* 类型的指针是为了存放 int 类型变量的地址。

### 2.1指针的解引用 ###

int main()
    {
    	int a = 0x11223344;
    	int* pa = &a;
    	*pa = 0;
    
    	return 0;
    }

![fe1ef6b56df2dc8a13d3c1a6f5a32ac6.png][]

![61a6837af00b6ab62b8799b8f4875c1a.png][]

**我们对上面代码进行修改，再来看看：**

int main()
    {
    	int a = 0x11223344;
    	char* pa = &a;
    	*pa = 0;
    
    	return 0;
    }

![f6dfb45a4735cb8288bcfd2bb6dac5cf.png][]

![7878dca0e2a721d67bde8e5da97e5cc4.png][]

**总结：**

指针类型决定了，在解引用指针的时候能访问几个字节。

对于整型指针解引用访问的是 4 个字节，对于字符指针解引用访问的是 1 个字节。

### 2.3 指针+-整数 ###

#include <stdio.h>
    int main()
    {
    	int a = 10;
    	int* pa = &a;
    	char* pc = &a;
    	printf("%p\n", pa);
    	printf("%p\n", pa+1);
    	printf("%p\n", pc);
    	printf("%p\n", pc+1);
    	return 0;
    }

![4df5e3c4517c1c99bb3cf48d175edf43.png][]

**总结：**

指针类型决定了，指针进行+1、-1的时候，一步走多大（距离）。

**举例：**创建一个数组，存放10个元素，初始化数组内容为1~10，并打印

#include <stdio.h>
    int main()
    {
    	int arr[10] = { 0 };
    	int* p = &arr[0];
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		*p = i + 1;
    		p++;
    	}
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }

**分析：**

![770332edf181730cbefcc68f9991bef0.png][]

![76a4ae5eebb3ba83c90f1ac0c104d14c.png][]

**因为 p 是整型指针，每一次+1操作都会跳过 4 个字节的空间，因此就可以用指针实现初始化为1~10的操作。**

## 3、野指针 ##

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

### 3.1野指针的成因 ###

#### 3.1.1.指针未初始化 ####

int main()
    {
    	int* p;//指针变量未初始化，默认为随机值
    	*p = 10;
    	return 0;
    }

**这里的局部变量\*p 没有初始化，默认为随机值，再进行赋值就是错误的。没有自己的空间存，因此就会出错。**

#### 3.12.指针越界访问 ####

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

![3ff1077b0824550095f2b3edb16f7b09.png][]

#### 3.1.3指针指向的空间释放 ####

**举例：**

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

![5f821b79af36d67fac0b9a69df303243.png][]

**因此这里的指针变量也是野指针。**

### 3.2 如何规避野指针 ###

**1.指针初始化**

**2.小心指针越界**

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

![f01846a422ca74e29ab26459b242f76e.png][]

**4.避免返回局部变量的地址**

**5.指针使用之前检查有效性**

**\* \* \* 在以后使用指针前可以使用条件判断，配 合指针使用，就不容易出错 \* \* \***

![5423cbc51cf1bb22b9114205781e7f70.png][]

## 4、指针运算 ##

### 4.1 指针 +- 整数 ###

**我们来看一段代码：**

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

**分析：**

![536d98153d98d27a60ec1cc974ac257b.png][]

**这里是 + ，是往后走。如果是 - 的话就是往前走，走的距离由类型决定。**

### 4.2 指针 - 指针 ###

**指针 - 指针 = 地址 - 地址**

**前提：**

**两个指针指向同一块空间（意味着指针的类型是一致的）**

**举例：**

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

**分析：**

![5026de8b03b357f53e03bd7864c203fa.png][]

*效果展示：*

![be2b450ff39b873d7859c693a55f61dc.png][]

**结论：****指针 - 指针得到的是指针和指针之间的元素个数（大地址 - 小地址是正的，小地址 - 大地址是负的）**

### 举例：求字符串长度 ###

这个我们是用计数器的方法写的

#include <stdio.h>
    int my_strlen(char* str)
    {
    	int count = 0;
    	while (*str != '\0')
    	{
    		count++;
    		str++;
    	}
    	return count;
    }
    int main()
    {
    	char str[] = "Hello World";
    	int res = my_strlen(str);
    	printf("%d\n", res);
    	return 0;
    }

我们接下来使用指针 - 指针的方式来写

#include <stdio.h>
    int my_strlen(char* str)
    {
    	char* start = str;
    	while (*str != '\0')
    	{
    		str++;
    	}
    	return str-start;
    }
    int main()
    {
    	char str[] = "Hello World";
    	int res = my_strlen(str);
    	printf("%d\n", res);
    	return 0;
    }

*效果展示：*

![37b4e4ab959ea69c8b8d769162576545.png][]

这里我们就是用到了**结论**。

### 4.3 指针的运算关系 ###

**我们来看一段代码：**

#define N_VALUES 5
    #include <stdio.h>
    int main()
    {
    	float values[N_VALUES];
    	float* vp;
    	for (vp = &values[N_VALUES]; vp > &values[0];)
    	{
    		*--vp = 0;
    	}
    	return 0;
    }

**分析：**

![effcad4d91cef651a095e36cbb9492c0.png][]

**上面的代码可读性不高，我们对代码进行****改进**

#define N_VALUES 5
    #include <stdio.h>
    int main()
    {
    	float values[N_VALUES];
    	float* vp;
    	for (vp = &values[N_VALUES-1]; vp >= &values[0]; --vp)
    	{
    		*vp = 0;
    	}
    	return 0;
    }

**分析：**

![f2ab9d3c5f7b49a62043e2b8c550025b.png][]

**改进后的代码实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。**

**标准规定：**

**允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针比较。**

改进后的代码在循环判断部分是>=，这就存在了首元素的地址与首元素之前的地址进行比较，这样是不可以的。

*画图深入理解一下：*

![3bc349cf3228200c885bd4ac047ee8b5.png][]

## 5、指针和数组 ##

**指针就是指针；数组就是数组。不等同，但是有连系。**

**我们举例来深入了解：**

#include <stdio.h>
    int main()
    {
    	int arr[10] = { 0 };
    	int* p = arr;//&arr[0] - 数组名是首元素地址
    	int i = 0;
    	for (i = 0; i < 10; i++)
    	{
    		*(p+i) = i + 1;
    	}
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", *(p+i));
    	}
    	return 0;
    }

*效果展示：*

![19b3838c4dd1518e988a0df725d590af.png][]

**Q:为什么可以使用指针对数组赋值呢？**

A：

1.指针可以指向数组元素

2.因为指针可以运算，所以借助于指针可以访问数组

![b82e9c03252c1847302008d6778e54bc.png][]

## 6、二级指针 ##

**我们来看这段代码：**

#include <stdio.h>
    int main()
    {
    	int a = 10;//a在内存中申请4个字节的空间
    	int* pa = &a;//pa是指针变量，用来存放地址，也得向内存申请4/8个字节，因此pa也是有地址的
    	int** ppa = &pa;//&pa的地址就放在ppa里面，因此ppa就是二级指针
    	//打印a
    	printf("%d\n", **ppa);
    	return 0;
    }

*效果展示：*

![09c5e1566103aa762efe5a93b8702a04.png][]

**分析：**

![b2b64dcdbd0d1d73d6c19dc8ab584464.png][]

![e32889afa6817fa1f52d57ed8dfbc385.png][]

## 7、指针数组 ##

> **指针数组是指针还是数组？**
> 
> **答案：是数组。是存放指针的数组。**
> 
> **数组我们已经知道整型数组、字符数组**

**我们以代码举例：**

#include <stdio.h>
    int main()
    {
    	int a = 10;
    	int b = 20;
    	int c = 30;
    	//指针数组 - 存放指针数组
    	int* arr[] = { &a, &b, &c };
    	//打印
    	int i = 0;
    	for (i = 0; i < 3; i++)
    	{
    		printf("%d ", *(arr[i]));
    	}
    	return 0;
    }

*效果展示：*

![e8d6acc4591d523fc3bd71875c90f8e4.png][]

**分析：**

**arr\[ \]数组是 int\* 类型的，说明存放的是指针，****这就是指针数组****，我们循环打印，对数组的每一位都解引用，就将数字全部打印出来了。**

### 引申： ###

#include <stdio.h>
    int main()
    {
    	char* ch[5];
    	char** chh = ch;
    	return 0;
    }

**分析：**

![d07367af15b9d649f8fbca5aadf418f3.png][]

### 指针数组使用 ###

**利用指针数组，将一维数组模拟出一个二维数组**

#include <stdio.h>
    int main()
    {
    	int arr1[] = { 1,2,3,4,5 };
    	int arr2[] = { 2,3,4,5,6 };
    	int arr3[] = { 3,4,5,6,7 };
    	//数组指针
    	int* arr[] = { arr1, arr2, arr3 };
    	//打印
    	int i = 0;
    	for (i = 0; i < 3; i++)
    	{
    		int j = 0;
    		for (j = 0; j < 5; j++)
    		{
    			printf("%d ", arr[i][j]);
    		}
    		printf("\n");
    	}
    	return 0;
    }

*效果展示：*

![36357dca4952f04e7e74e3f807ac5b5e.png][]

**这里的 arr 里面的 arr1、arr2、arr3 在内存中不一定连续，这只是模拟，但是存储就不一定是二维数组那样的在内存中连续存储了。但是 arr1、arr2、arr3 分别是连续的，因为分别是一维数组。**

## 引申： ##

**我们来看这段代码：**

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

*效果展示：*

![9b62f10ffddd474c47bcf4e9ff5822e8.png][]

**我们可以看到，这里&arr\[i\] 和 p+i 取出的地址是一样的。****因此我们对 p+i 解引用也就是数组的每一个元素。**

**我们来看代码：**

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

*效果展示：*

![1b8727a27c3149f2c51823436fe3c16e.png][]

**分析：**

**我们 p 存的是 arr ，数组名也是首元素地址，我们是对 p+i 解引用得到的数组元素，那么我们不借用中间变量，直接对 arr+i 解引用也就是把数组的每一位元素打印出来了。编译器就是通过这样的方式对数组的每一位进行打印的。因此 arr\[ i \] = \*( arr+i )。**

**在数组传参的时候，形参部分写成指针或者数组都是一样的，都是支持的。**

**我们来试试看看分析是否正确**

#include <stdio.h>
    int main()
    {
    	int arr[] = { 1,2,3,4,5 };
    	int i = 0;
    	//打印
    	for (int i = 0; i < 5; i++)
    	{
    		printf("%d = %d\n", arr[i], *(arr+i));
    	}
    	return 0;
    }

*效果展示：*

![222ed0393f9c8d8530ee79ff0b3897d6.png][]

**看来我们上面的分析是正确的，我们继续分析：**

**我们这里是对 arr+i 解引用得到数组每一个元素的，这里用的是加法，加法是支持交换律的，那是不是就可以将arr 与 i 交换再解引用也可以得到数组每一个元素，如果可以那这就意味着 i\[arr\] 这种形式也是可以的。**

**我们用代码来验证一下：**

#include <stdio.h>
    int main()
    {
    	int arr[] = { 1,2,3,4,5 };
    	int i = 0;
    
    	for (int i = 0; i < 5; i++)
    	{
    		printf("%d = %d\n", i[arr], *(i+arr));
    	}
    	return 0;
    }

*效果展示：*

![8e2f25b714e923259577b12674a9211b.png][]

**原来我们分析的是对的，这样也是可以的。**

**总结：**

**指针数组这里是存在等价关系的。**

![2a085bbf2631104f6ec2a276d2b50664.png][]

**但是这里我们平时是不以 i\[arr\] 这样的方式写的，主要还是用 arr\[i\] 的方式写。**

**我们再来想二维数组**

![231b7b487c7efaf65f364d524e16a4c3.png][]

**在二维数组里这都是等价的。**

哈哈哈，又学到了，指针也不是那么难，我们继续坚持，肯定可以攻克它，冲冲冲！！！

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*本片结束\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

[59a9509d13f1f597529677e9ba4ad09c.png]: https://img-blog.csdnimg.cn/img_convert/59a9509d13f1f597529677e9ba4ad09c.png
[fe1ef6b56df2dc8a13d3c1a6f5a32ac6.png]: https://img-blog.csdnimg.cn/img_convert/fe1ef6b56df2dc8a13d3c1a6f5a32ac6.png
[61a6837af00b6ab62b8799b8f4875c1a.png]: https://img-blog.csdnimg.cn/img_convert/61a6837af00b6ab62b8799b8f4875c1a.png
[f6dfb45a4735cb8288bcfd2bb6dac5cf.png]: https://img-blog.csdnimg.cn/img_convert/f6dfb45a4735cb8288bcfd2bb6dac5cf.png
[7878dca0e2a721d67bde8e5da97e5cc4.png]: https://img-blog.csdnimg.cn/img_convert/7878dca0e2a721d67bde8e5da97e5cc4.png
[4df5e3c4517c1c99bb3cf48d175edf43.png]: https://img-blog.csdnimg.cn/img_convert/4df5e3c4517c1c99bb3cf48d175edf43.png
[770332edf181730cbefcc68f9991bef0.png]: https://img-blog.csdnimg.cn/img_convert/770332edf181730cbefcc68f9991bef0.png
[76a4ae5eebb3ba83c90f1ac0c104d14c.png]: https://img-blog.csdnimg.cn/img_convert/76a4ae5eebb3ba83c90f1ac0c104d14c.png
[3ff1077b0824550095f2b3edb16f7b09.png]: https://img-blog.csdnimg.cn/img_convert/3ff1077b0824550095f2b3edb16f7b09.png
[5f821b79af36d67fac0b9a69df303243.png]: https://img-blog.csdnimg.cn/img_convert/5f821b79af36d67fac0b9a69df303243.png
[f01846a422ca74e29ab26459b242f76e.png]: https://img-blog.csdnimg.cn/img_convert/f01846a422ca74e29ab26459b242f76e.png
[5423cbc51cf1bb22b9114205781e7f70.png]: https://img-blog.csdnimg.cn/img_convert/5423cbc51cf1bb22b9114205781e7f70.png
[536d98153d98d27a60ec1cc974ac257b.png]: https://img-blog.csdnimg.cn/img_convert/536d98153d98d27a60ec1cc974ac257b.png
[5026de8b03b357f53e03bd7864c203fa.png]: https://img-blog.csdnimg.cn/img_convert/5026de8b03b357f53e03bd7864c203fa.png
[be2b450ff39b873d7859c693a55f61dc.png]: https://img-blog.csdnimg.cn/img_convert/be2b450ff39b873d7859c693a55f61dc.png
[37b4e4ab959ea69c8b8d769162576545.png]: https://img-blog.csdnimg.cn/img_convert/37b4e4ab959ea69c8b8d769162576545.png
[effcad4d91cef651a095e36cbb9492c0.png]: https://img-blog.csdnimg.cn/img_convert/effcad4d91cef651a095e36cbb9492c0.png
[f2ab9d3c5f7b49a62043e2b8c550025b.png]: https://img-blog.csdnimg.cn/img_convert/f2ab9d3c5f7b49a62043e2b8c550025b.png
[3bc349cf3228200c885bd4ac047ee8b5.png]: https://img-blog.csdnimg.cn/img_convert/3bc349cf3228200c885bd4ac047ee8b5.png
[19b3838c4dd1518e988a0df725d590af.png]: https://img-blog.csdnimg.cn/img_convert/19b3838c4dd1518e988a0df725d590af.png
[b82e9c03252c1847302008d6778e54bc.png]: https://img-blog.csdnimg.cn/img_convert/b82e9c03252c1847302008d6778e54bc.png
[09c5e1566103aa762efe5a93b8702a04.png]: https://img-blog.csdnimg.cn/img_convert/09c5e1566103aa762efe5a93b8702a04.png
[b2b64dcdbd0d1d73d6c19dc8ab584464.png]: https://img-blog.csdnimg.cn/img_convert/b2b64dcdbd0d1d73d6c19dc8ab584464.png
[e32889afa6817fa1f52d57ed8dfbc385.png]: https://img-blog.csdnimg.cn/img_convert/e32889afa6817fa1f52d57ed8dfbc385.png
[e8d6acc4591d523fc3bd71875c90f8e4.png]: https://img-blog.csdnimg.cn/img_convert/e8d6acc4591d523fc3bd71875c90f8e4.png
[d07367af15b9d649f8fbca5aadf418f3.png]: https://img-blog.csdnimg.cn/img_convert/d07367af15b9d649f8fbca5aadf418f3.png
[36357dca4952f04e7e74e3f807ac5b5e.png]: https://img-blog.csdnimg.cn/img_convert/36357dca4952f04e7e74e3f807ac5b5e.png
[9b62f10ffddd474c47bcf4e9ff5822e8.png]: https://img-blog.csdnimg.cn/img_convert/9b62f10ffddd474c47bcf4e9ff5822e8.png
[1b8727a27c3149f2c51823436fe3c16e.png]: https://img-blog.csdnimg.cn/img_convert/1b8727a27c3149f2c51823436fe3c16e.png
[222ed0393f9c8d8530ee79ff0b3897d6.png]: https://img-blog.csdnimg.cn/img_convert/222ed0393f9c8d8530ee79ff0b3897d6.png
[8e2f25b714e923259577b12674a9211b.png]: https://img-blog.csdnimg.cn/img_convert/8e2f25b714e923259577b12674a9211b.png
[2a085bbf2631104f6ec2a276d2b50664.png]: https://img-blog.csdnimg.cn/img_convert/2a085bbf2631104f6ec2a276d2b50664.png
[231b7b487c7efaf65f364d524e16a4c3.png]: https://img-blog.csdnimg.cn/img_convert/231b7b487c7efaf65f364d524e16a4c3.png