☃️内容专栏：【C语言】初阶部分

☃️本文概括：继初识C语言，对C语言指针初阶部分进行归纳与总结。

☃️本文作者：花香碟自来_ 

☃️发布时间：2023.2.17

目录

一、指针和指针类型

1.1 指针

 1.2 指针类型

其一（指针的解引用）：

 其二（指针+-整数）：

1.3指针的类型的应用

二、野指针

2.1野指针成因

1. 指针未初始化

 2.指针越界访问

3.指针指向的空间释放

2.2 如何规避野指针

三、指针运算

3.1指针加减整数

3.2指针减去指针

3.3指针的关系运算

四、指针和数组

五、二级指针

六、指针数组

一、指针和指针类型

1.1 指针

在初识C语言中，我们就知道：

1. 指针是内存中一个最小单元的编号，也就是地址（编号 == 地址 == 指针）
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量。
3. 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

所以我们有总结：

1.  指针变量是用来存放地址的，地址是唯一标示一个内存单元的。
2.  指针的大小在32位平台是4个字节，在64位平台是8个字节 

int main()
{int a = 10;//a是整型 占用四个字节的内存空间，每个字节都有对应的地址编号int* pa = &a;//pa是指针变量//&a得到是a的地址（指针），其实得到的是a所占内存中4个字节的起始地址（第一个字节的地址）return 0;
}

 1.2 指针类型

我们知道变量都有不同的类型，char 、int 、short、float……每个类型对应的大小都不同。而指针变量也有相应的类型。

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

我们知道指针变量的大小与数据类型无关，在32位平台上都是4个字节，那么我们只需定义一个指针变量就可以了呀，其实不然，下面就此讨论指针类型的意义。

指针类型的意义：

其一（指针的解引用）：

观察以下代码

我们通过调试—>内存—>&a—>将十六进制的数字“0x11223344”存储到了a当中，a的地址为0x00aff998，我们*pa会发生什么呢？
我们继续按F10调试，a的4个字节的大小都变成了0.

如果我们强制把a的地址存放到char*的空间里面去（会报警告，显示从int* 到char* 的类型不兼容，这里不影响调试），观察以下代码

这时，我们发现*pc = 0，调试后，只是将第一个字节的数据改为了0，

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

 其二（指针+-整数）：

 观察以下代码

 我们分别把a的地址存放到int* 和char* 里面去，分别打印pa 、pa + 1以及pc ，pc + 1的地址，我们不难发现

• pa与pc的地址是一样的，因为pa与pc存放的都是a的起始地址。
• pa + 1则在pa指针变量的基础上跳过了4个字节的大小，因为pa指针变量指向的是一个int类型，所以 + 1的操作就是跳过一个整型的大小。
• pc + 1同理，因为pc指针变量指向的是一个char类型的大小，+ 1就会跳过一个字符类型的大小。

所以，pa+n等于加上了n*sizeof（int），pc+n等于加上了n*sizeof（char）

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

1.3指针的类型的应用

#include
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;
}

 运行结果：

二、野指针

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

2.1野指针成因

1. 指针未初始化

int main()
{int* p; //未初始化，p指向位置的是未知的(随机的)，p就是野指针*p = 10;return 0;
}

 2.指针越界访问

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

3.指针指向的空间释放

int* test()
{int a = 10;return &a;
}
int main()
{int* p = test();*p = 20;return 0;
}

test调用之后返回的是局部变量的地址，但是实际的a变量不存在了，已经出了函数的作用域，已经销毁了，此时的p指针变量就是一个野指针。

2.2 如何规避野指针

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

#include 
int main()
{int *p = NULL;int a = 10;p = &a;if(p != NULL){*p = 20;}return 0;
}

三、指针运算

3.1指针加减整数

#define N_VALUES 5
int main()
{float values[N_VALUES];float* vp;//指针+-整数；指针的关系运算for (vp = &values[0]; vp < &values[N_VALUES];){*vp++ = 0;}return 0;
}

3.2指针减去指针

我们思考以下代码，

#include
int main()
{int arr[] = { 1,2,3,4,5,6,7,8,9,10 };int n = &arr[9] - &arr[0];//得到的是之间元素的个数printf("%d", n);return 0;
}

我们在前面知道，指针加上一个整数等于一个指针，那么在这里我们其实就不难发现，指针减去指针得到的是两个指针之间的元素个数。

学到这里，我们是不是可以用指针模拟实现一个strlen库函数

代码如下：

#include
int my_strlen(char* str)
{char* begin = str;while (*str != '\0'){str++;}return str - begin;
}
int main()
{char str[] = "abcdef";printf("%d", my_strlen(str));return 0;
}

3.3指针的关系运算

我们将3.1的代码修改一下，得到以下代码

代码1：

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

 代码简化，将代码修改一种方式：

代码2：

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

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

标准规定：允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

四、指针和数组

指针就是指针，数组就是数组。但指针和数组是有关联的。

 数组名是数组首元素的地址。（两种情况除外，前面提到过，可以看看数组章节部分的知识）

#include 
int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9,0};int* p = arr;//p存放的是数组首元素的地址printf("%p\n", arr);printf("%p\n", &arr[0]);return 0;
}

 利用指针访问数组的元素

将int arr[10] = {0} 的元素通过指针初始化为1 2 3 4 … 10.

#include
int main()
{int arr[10] = { 0 };int* p = arr;int i = 0;	for (i = 0; i <  10; i++){*p = i + 1;//存放数据p++;}//打印p = arr;for (i = 0; i < 10; i++){printf("%d ",*(p + i));}return 0;
}

五、二级指针

我们知道，指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里呢?

这里，我们就要讲到二级指针的概念。

#include
int main()
{int a = 10; //a在内存中申请了4个字节的空间//一级指针int* pa = &a;//0x0012ff40 pa是指针变量，用来存放地址，也得申请4(8)个字节的空间//二级指针int** ppa = &pa;//0x0012ff44printf("%p",*ppa);//得到的是paprintf("%d",**ppa);//得到的是areturn 0;
}

 画图表示： 

 解释：int* pa = &a将变量a的地址存放到指针变量pa中去，*表示pa是指针，int说明pa指向的变量是int类型，此时的pa是一个一级指针；int** ppa = &pa，取出指针变量pa的地址，存放到指针变量ppa当中去，*表示ppa是指针，int*则说明ppa指向的pa是int*类型，此时的ppa就是一个二级指针。

• *ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa，pa是地址，用%p打印
• **ppa 先通过 *ppa 找到 pa ,然后对 pa 再进行解引用操作： *pa ，那么找到的就是a了。

六、指针数组

指针数组是数组还是指针呢？答案是数组，指针数组指的是存放指针的数组，我们观察以下代码具体了解。

#include
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;
}

☃️ 以上就是初阶指针部分的详细内容，创作不易，还请各位多加关注、点赞、收藏，感谢支持~