初始C语言（7）——详细讲解有关初阶指针的内容

- 日理万妓 2023-10-14 21:44 7阅读 0赞

## 系列文章目录 ##

第一章 [“C“浒传——初识C语言（1）（更适合初学者体质哦！）][C_C_1]

第二章 [初始C语言（2）——详细认识分支语句和循环语句以及他们的易错点][C_2]

第三章 [初阶C语言（3）——特别详细地介绍函数][C_3]

第四章 [初始C语言（4）——详细地讲解数组的内容以及易错点][C_4]

第五章 [初始C语言（5）——详细讲解操作符以及操作符的易错点][C_5]

第六章 [初始C语言（6）——详细讲解表达式求值以及其易错点][C_6]

第七章 初始C语言（7）——详细讲解有关初阶指针的内容

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

**目录**

系列文章目录

前言

一、指针是什么？

1.1 指针

总结：指针就是地址，口语中受到指针通常是指针变量。

1.2 指针变量

1.3 内存

1.2.1 什么是内存：

1.2.2 内存的抽象模型：

二、指针和指针类型

2.1 指针的解引用

2.2 指针 +- 整数

2.3 指针类型的应用

三、野指针

3.1 野指针成因

3.2 如何规避野指针

3.2.1 指针初始化要注意两个点

3.2.2 指针使用之前要检查有效性

悬空指针

四、指针运算

4.1 指针 +- 整数

4.2 指针 - 指针

4.3 指针的关系运算

五、指针和数组

六、二级指针

七、指针数组

总结

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

## 前言 ##

> 在上一章内，小编带领大家详细学习了**有关表达式求值的相关内容**，学习了**隐式类型转换和显式类型转换的相关内容**，**介绍了操作符的一些属性**。
> 
> 而在这一章内，**小编要带领大家进行学习初阶指针的一些内容**，不要害怕，**这一部分只是为了后面讲述进阶指针做一个铺垫**，所以不要担心指针这一节很难，当你刚开始就害怕的话，你将永远地活在这个阴影之下，会永远学不会这一章的内容，希望大家能够有耐心地将这一章看完！

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

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

说起指针，小编当年也是比较害怕的，因为指针算的上是C语言中很难的一个知识点，但是一般写代码的时候也不常用，导致很多人不是非常重视，所以请认真学习一下这一节，刚开始先讲一下之前讲过的东西。

> **指针理解的两个要点：**
> 
> 1.  指针是**内存**中一个最小单元的编号，也就是地址；
> 2.  平时口语中说的指针，通常指的是**指针变量**，是用来存放地址的变量。

### 1.1 指针 ###

*  指针是C语言非常重要的特征，指针也是一种变量，只不过它所表示的不是数据的值，而是内存的地址。
 *  通过使用指针，可以对任意（非绝对）内存地址的数据进行读写。
 *  在了解指针读写的过程前，我们先需要了解如何定义一个指针，和普通的变量不同，在定义指针时，我们通常会在变量名前加一个\*号。

我们以32位计算机为例，32位计算机的内存地址是4个字节，在这种情况下，指针的长度也是32位。下面会讲解32位计算机的地址线。

### **总结：****指针就是地址，口语中受到指针通常是指针变量。** ###

在上面总结中有**两个名词：内存、指针变量**。 我们先来认识一下指针变量，再来认识一下内存。

### 1.2 指针变量 ###

在前面[初始C语言（5）——详细讲解操作符以及操作符的易错点][C_5]我们学过一个操作符 & ，我们可以**通过 & （取地址操作符）取出变量的内存其实就是地址**，把地址可以存放在一个变量中，这个变量就是指针变量。在了解指针读写的过程前，我们先需要了解如何定义一个指针，和普通的变量不同，在定义指针时，我们通常会在变量名前加一个 **\*** 号。

>     int main()
>     {
>     	int a = 0x11223344; //在内存中开辟一个空间
>     	int* p = &a;//这里我们对变量a，取出他的地址
>     	//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p是一个指针变量。
>     	return 0;
>     }
> 
> ![e966a611b4614d1382fb307e19037f77.png][]

**总结：**指针变量就是用来存放地址的变量。（存放在指针中的值都被当成地址处理）

### 1.3 内存 ###

可能大家对内存的理解都不是很到位，在这里小编将要带领大家进行深一步学习，大家先记住一句话就是：内存和存储空间不是一回事。（更加详细地请看[内存][Link 1]）

#### 1.2.1 什么是内存： ####

*  **内存是计算机中的重要部件，也称内存储器和[主存储器][Link 2]，它是程序和CPU进行沟通的桥梁。**
 *  **计算机中所有程序的运行都在内存中进行，****它用于暂时存放CPU中的运算数据，以及与硬盘等[外部存储器][Link 3]交换的数据。内存性能的强弱影响计算机整体发挥的水平。**
 *  **只要计算机开始运行，操作系统就会把需要运算的数据从内存调到CPU中进行运算，当运算完成，CPU将结果传送出来。**

![95349d1c54a0461296f91d3bd9a58b56.png][]

#### 1.2.2 内存的抽象模型： ####

为了方便大家记住，我们把内存模型映射成为我们现实生活中的模型，内存的模型是一层一层的，在现实生活中，其很像我们生活中的高楼大厦。

在这个高楼大厦中，一层可以存储一个字节的数据，楼层号就是地址，下面是内存和楼层整合的模型图。

![529c0a13811b4a5288c0113e4bfdc9ee.png][]

*  我们知道程序中的数据不仅只有数值，还有数据类型的概念 ，从内存上看就是占用内存大小（占用楼层数）的意思。
 *  即使物理上强制以1个字节为单位来逐一读写数据的内存，在程序中，通过指定其数据类型，也能实现以特定字节数为单位来进行读写。

在上面的讲解中也会有**一些问题：**

*  一个小的单元到底是多大？（一个字节）
 *  如何编址？

我们先来回答**第一个问题：**经过仔细地计算和权衡会发现一个字节给一个对应的地址是比较合适的。因为最小的数据类型是char，其单位为一个字节。**如果过小，不好存储数字；如果过大，又很浪费空间。**

那么回答**第二个问题：** 对于32位的机器，假设有32根[地址线][Link 4]，那么假设每根地址线在寻址的时候产生**高电平（高电压）**和**低水平（低电压）**就是**（1或者0）**；那么32根地址线产生的地址就会是：

> 00000000 00000000 00000000 00000000
> 
> 00000000 00000000 00000000 00000001
> 
> 00000000 00000000 00000000 00000002
> 
> ......
> 
> 11111111 11111111 11111111 11111111

这里就有2的32次方个地址，每一个地址表示一个字节。那我们就可以给（2^32byte == 2^32/1024KB == 2^32/1024/1024MB == 2^32/1024/1024/1024GB == 4GB）4G的空间进行编址。同样的方法，那64位机器如果给64根地址线，那能编址多大空间？答案是16G的空间。

**但这里我们应该明白：**

*  在32位机器上，地址是32个0或者1组成的二进制序列，那地址就要用4个字节（一个字节是8个byte）的空间进行存储，所以一个字节变量的大小就应该是4个字节。
 *  那如果是在64位机器上，如果有64个地址线，那一个字节变量的大小是8个字节，才能存放一个地址。

**总结：**

*  指针是用来存放地址的，地址是唯一标识一块地址空间的。
 *  指针的大小在32位平台是4个字节，在64位平台上是8个字节。

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

## 二、指针和指针类型 ##

在之前，我们学习变量时，会根据现实生活提供**不同的类型：**整形，浮点型等……那么指针有没有类型呢？准确地说：有的。

当有这样的代码：

int num = 10;
    p = &num;

我们**要将 &num（num的地址）保存到p中**，我们知道**p是一个指针变量**，那么它的类型是什么呢？我们要给指针变量相应的类型。

char*   pc = NULL;
    int*    pc = NULL;
    short*  pc = NULL;
    long*   pc = NULL;
    float*  pc = NULL;
    double* pc = NULL;

这里可以看到，指针的定义方式是：**type + \*** 。

其实：

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

那为什么要这么麻烦？指针变量的大小不是都是**4或者8个字节**吗？那指针类型的意义是什么？请看下面进行讲解：

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

>     #include <stdio.h>
>     int main()
>     {
>     	int n = 0x11223344;
>     	char* pc = (char*)&n; //为了消除警告
>     	int* pi = &n;
>     	*pc = 0;//重点在调试的过程中观察内存的变化
>     	*pi = 0;//重点在调试的过程中观察内存的变化
>     	return 0;
>     }
> 
> ![d6ccce1a4f874b3cadf95783c9647c41.jpeg][]
> 
> 在调试过程中，我们可以发现，指针类型是有意义的，指针类型决定了指针进行解引用操作时，访问几个字节。

**总结：**

**指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。**比如：**char\*** 的指针解引用就只能访问一个字节，而 **int\*** 的指针解引用就能访问四个字节。

经过上面的学习，有些人可能要疑惑，为什么不自动识别传来的地址是什么类别的呢？ 其实是已经识别了。

![e0138b5d16424983a10eebaae8673439.png][]

### 2.2 指针 +- 整数 ###

>     #include <stdio.h>
>     int main()
>     {
>     	int n = 10;
>     	char* pc = (char*)&n;
>     	int* pi = &n;
>     	printf("%p\n", &n);
>     	printf("%p\n", pc);
>     	printf("%p\n", pc + 1);
>     	printf("%p\n", pi);
>     	printf("%p\n", pi + 1);
>     	return 0;
>     }
> 
> ![3453812daf7046ef91aa1b46409fcdf1.png][]为什么这两个指针跳过的大小不同呢？
> 
> 首先，这两个指针的类型是不一样的；
> 
> 其次，整形类型指针指向的是一个整形的对象；字符类型指针指向的是一个字符的对象。

**总结：**

指针的类型决定了指针向前或者向后走一步跳过几个字节（距离）。 比如：一个 **char\*** 的指针加1跳过一个字节，一个 **int\*** 的指针加1跳过4个字节。

### 2.3 指针类型的应用 ###

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

## 三、野指针 ##

> 野指针，顾名思义就是不确定的指针，大家可以用野人来类比。**概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）**

**说明：**指针变量也是变量，在前面我们知道如果变量不初始化，在内存中会存放随机值（全局变量不初始化，存放0，局部变量不初始化，存放随机值）。同理**指针变量如果赋给随机值是没有意义的，会成为野指针的。**随机值会导致指针无法指向一个有效的内存空间，操作系统不允许操作此指针指向的内存区域。

**注释：**野指针是不会直接引发错误的，而野指针指向的内存空间会出现问题的。

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

**1.指针未初始化：**指针变量终究只是一个变量（就和全局变量与局部变量一样），如果不给这个变量进行初始化，那么这个变量将会存放随机值

**下面进行代码演示：**

int* p; //局部变量指针为初始化，默认为随机值
    //正确写法为：int* p = NULL;
        *p = 20;

**2.指针越界访问：**在[数组][Link 5]这一节中，我们学习数组越界访问，其实指针越界访问与其类似，指针指向的空间超出了其分配的合理空间。

**下面进行代码演示：**

int arr[10] = {0};
        int* p = arr;
        for(int i = 0; i <= 10; i++)
    //正确写法为：for(int i = 0; i < 10; i++)
        {
            //当指针指向的范围超出数组arr的范围时，p就是野指针
            *(p++) = i;
        }

**3.指针指向的空间释放：**在未学习动态内存开辟时，我们先用函数释放来解释这个成因。建立一个返回值为指针类型的函数，在主函数中用指针变量进行接收，当程序出函数体后，原先函数所指向的空间进行释放，此时指针就为野指针。

**下面进行代码演示：**

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

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

1.  指针初始化
2.  小心指针越界
3.  指针指向的空间释放，及时置NULL
4.  避免放回局部变量的地址
5.  指针使用之前检查有效性

#### 3.2.1 指针初始化要注意两个点 ####

> 先看代码，进行举例：
> 
>     int a = 10;
>     int* p = &a;
> 
>  *  如果明确指针应该指向哪里的话，就应该初始化正确的地址

>  *  如果不能明确指针应该指向哪里的话，安全起见要将指针初始化为NULL （空指针，就是0）
> 
> ![fad70806ae9f4dc7b48a6b4e77f7efe0.png][]

#### 3.2.2 指针使用之前要检查有效性 ####

#include <stdio.h>
    int main()
    {
        int* p = NULL; //不管三七二十一，我们要进行初始化
        //……
        int a = 10;
        p = &a;
        if(p != NULL)
            *p = 20;
        return 0;
    }

> 在这里，我们要先说一句，NULL是0，其实它也是一个地址，但是在我们用户手中是无法访问的，一旦我们去访问，程序就会崩溃。

### 悬空指针 ###

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

## 四、指针运算 ##

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

int main()
    {
    	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
    	//            0 1 2 3 4 5 6 7 8 9 
    	//使用指针打印数组的内容
    	int* p = arr;
    	for (int i = 0; i < 10; i++)
    	{
    		printf("%d ", *(p + i));
    		//p指向的是数组首元素
    		//p+i 是数组中下标为i的元素的地址
            //p+i 起始时跳过了i*sizeof(int)个字节
    	}
    	printf("\n");
    	return 0;
    }

> 扩展：arr == p
> 
> arr+i == p+i
> 
> \*(arr+i) == \*(p+i) == arr\[i\]
> 
> \*(i+arr) == i\[arr\]

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

*  指针 - 指针的前提是：两个指针指向同一块区域，指针类型相同的
 *  指针 - 指针差值的绝对值是：指针和指针之间的元素个数

int arr[10];
    printf("%d\n", &arr[0] - &arr[9]);  //-9
    printf("%d\n", &arr[9] - &arr[0]);  //9

![585be0ccf67741e4a86bd36efd9cc393.png][]

**模拟实现一下strlen（）函数：**

size_t my_strlen(char* ptr)
    {
        char* s = ptr;
        while(*s)
    //还可以这样写：while(*s != '\0')
            s++;
        return s - ptr;
    }

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

#define N_VALUES 5
    for(vp = &values[N_VALUES];vp > &values[0];)
    {
        *--vp = 0;
    }

代码简化，将这个代码进行修改：

for(vp = &values[N_VALUES];vp > &values[0]; vp--)
    {
        *vp = 0;
    }

实际上在绝大部分的编译器上是可以顺利完成任务的，然而我们还是要避免这样写，因为标准并不能保证这个方法可行。

> **标准规定：** 
> 
> 在C语言中，允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。
> 
> ![a00a1125f1ac40e59441311ebe63fc45.png][]

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

## 五、指针和数组 ##

在一小部分中，我们要知道：

*  指针就是指针，指针变量就是变量，是用来存放地址的，指针变量的大小是4/8个字节
 *  数组就是数组，可以存放一组数，数组的大小是取决于元素的类型和个数
 *  数组的数组名是数组首元素的地址（两种情况除外），指针变量是可以访问地址的

![c74817a1e0294f44a093a048d5fd851d.png][]

在绝大多数情况下，数组名和数组首元素的地址是一样的，看下图：

![fb1e54c3cde24049b1cedddcba6de634.png][]

> **总结：**
> 
> 数组名表示数组首元素的地址。 
> 
> 但是有两个例外：
> 
> 1.  sizeof(数组名)，数组名单独放在sizeof内部，数组名表示整个数组，计算的是数组的大小，单位是字节。
> 2.  &数组名，数组名表示整个数组，取出的是数组的地址。数组的地址和数组首元素的地址，值是一样的，但是类型和意义是不一样的。

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问就成为可能，那我们可以直接通过指针来访问数组。看下下面代码：

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

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

## 六、二级指针 ##

指针变量也是变量（一级指针变量），是变量就有地址，那指针变量的地址存放在哪里？这个就是二级指针。下面就是代码解释：

int a = 10;
    int* p = &a; //p是指针变量，一级指针变量
    int* * pp = &p; //pp是指针变量，二级指针变量
    //你还可以继续写，有几个*,就是几级指针变量
    //int** * ppp = &pp; //ppp是指针变量，三级指针变量

![1d84a4c432124d568d7e3dd3106d6e88.png][]

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

## 七、指针数组 ##

指针数组是指针还是数组呢？答案是：是数组，是存放指针的数组。我们可以使用指针数组来模拟实现一个二维数组。

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 };
    	for (int i = 0; i < 5; i++)
    	{
    		for (int j = 0; j < 5; j++)
    		{
    			printf("%d ", arr[i][j]);
    		}
    		printf("\n");
    	}
    	return 0;
    }

![f435b80c23eb48f6bf6021c9f7de1d85.png][]

## 总结 ##

在这一部分，小编详细地编写了有关初阶指针的一篇博客。希望大家看完以后，进行点评，谢谢大家！

[C_C_1]: http://t.csdn.cn/Rt8VK
[C_2]: http://t.csdn.cn/pTO5k
[C_3]: http://t.csdn.cn/R6aDv
[C_4]: http://t.csdn.cn/z7pdJ
[C_5]: http://t.csdn.cn/NcxMW
[C_6]: http://t.csdn.cn/pIje8
[e966a611b4614d1382fb307e19037f77.png]: https://img-blog.csdnimg.cn/e966a611b4614d1382fb307e19037f77.png
[Link 1]: http://t.csdn.cn/qVY1m
[Link 2]: https://baike.baidu.com/item/%E4%B8%BB%E5%AD%98%E5%82%A8%E5%99%A8/10635399
[Link 3]: https://baike.baidu.com/item/%E5%A4%96%E9%83%A8%E5%AD%98%E5%82%A8%E5%99%A8/4843180
[95349d1c54a0461296f91d3bd9a58b56.png]: https://img-blog.csdnimg.cn/95349d1c54a0461296f91d3bd9a58b56.png
[529c0a13811b4a5288c0113e4bfdc9ee.png]: https://img-blog.csdnimg.cn/529c0a13811b4a5288c0113e4bfdc9ee.png
[Link 4]: http://t.csdn.cn/eLKMD
[d6ccce1a4f874b3cadf95783c9647c41.jpeg]: https://img-blog.csdnimg.cn/d6ccce1a4f874b3cadf95783c9647c41.jpeg
[e0138b5d16424983a10eebaae8673439.png]: https://img-blog.csdnimg.cn/e0138b5d16424983a10eebaae8673439.png
[3453812daf7046ef91aa1b46409fcdf1.png]: https://img-blog.csdnimg.cn/3453812daf7046ef91aa1b46409fcdf1.png
[Link 5]: http://t.csdn.cn/r8qC6
[fad70806ae9f4dc7b48a6b4e77f7efe0.png]: https://img-blog.csdnimg.cn/fad70806ae9f4dc7b48a6b4e77f7efe0.png
[585be0ccf67741e4a86bd36efd9cc393.png]: https://img-blog.csdnimg.cn/585be0ccf67741e4a86bd36efd9cc393.png
[a00a1125f1ac40e59441311ebe63fc45.png]: https://img-blog.csdnimg.cn/a00a1125f1ac40e59441311ebe63fc45.png
[c74817a1e0294f44a093a048d5fd851d.png]: https://img-blog.csdnimg.cn/c74817a1e0294f44a093a048d5fd851d.png
[fb1e54c3cde24049b1cedddcba6de634.png]: https://img-blog.csdnimg.cn/fb1e54c3cde24049b1cedddcba6de634.png
[1d84a4c432124d568d7e3dd3106d6e88.png]: https://img-blog.csdnimg.cn/1d84a4c432124d568d7e3dd3106d6e88.png
[f435b80c23eb48f6bf6021c9f7de1d85.png]: https://img-blog.csdnimg.cn/f435b80c23eb48f6bf6021c9f7de1d85.png