【C语言】带你完全理解指针（二）(1)

讲解：arr1、arr2、arr3都是整型数组，arr是整型数组指针，他的每一个元素都是指针类型是int*，（因为数组名是数组首元素的地址）

用i来遍历arr数组，用j来遍历指针指向的数组即arr1、arr2、arr3.

---

3.数组指针

1.数组指针的定义

再来类比一下

整型指针：指向整型变量的指针，存放的整型变量的地址的指针变量

字符指针：指向字符变量的指针。存放字符变量的地址的指针变量

那数组指针就是指向数组的指针，存放的是数组的地址的指针变量

下面哪个是数组指针？

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？

p2是数组指针。

p2先和*结合，说明p2是一个指针变量，然后指着指向的是一个大小为10个整型的数组，数组的元素是指针，也就是p1是指针数组。

所以p2是一个指针，指向一个数组，这个数组是数组指针。

这里要注意：[ ]的优先级要高于*号的，所以必须加上（）来保证p2先和*结合。

---

2 &数组名VS数组名

数组名就是地址，通常来说：数组名是数组首元素的地址。

但是，存在两种特殊情况：

1、sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。

2、&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。

除此之外，所有遇到的数组名都是数组首元素的地址。

第一组和第二组+1时都只是跳过四个字节，即arr表示的是首元素地址。

而第三组可以发现，&arr和&arr+1之间跳过了40个字节，即一整个数组的大小，因此证明&arr表示整个数组。

一种错误的数组指针的写法：

int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	//数组的地址，存储到数组指针变量
	//int[10] *p = &arr;//err
	int (* p)[10] = &arr;//int(*)[10]

	int* p2 = &arr;//err

	return 0;
}

因为[]的优先级高于*操作符。不能把一个数组的地址塞给一个指针，一个指针的大小是4字节或者8字节，这里这个数组是10个元素，40个字节。所以应该塞给一个数组指针才对。

int (* p)[10] = &arr;

---

3 数组指针的使用

不使用数组的访问操作符，而是使用数组指针

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int (*p)[10] = &arr;//*&arr --> arr
	int i = 0;
	for (i = 0; i < 10; ++i)
	{
		//printf("%d ", *((*p) + i));
		printf("%d ", (*p)[i]);
	}

	return 0;
}

数组指针怎么使用呢？一般在二维数组上使用才方便

创建一个二位数组之后，使用自己写的一个函数print来打印，先看看简单常见的写法。二维数组传参，形参使用二维数组的形式。

void Print(int arr[3][5], int r, int c)
{
	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");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };
	Print(arr, 3, 5);

	return 0;
}

现在我们学习了数组指针的知识，其实二维数组传参，形参可以是数组指针的形式。

先来看看对二位数组的理解：

二维数组的每一行可以理解为二维数组的一个元素。每一行又是一个一维数组。所以二维数组其实是一维数组的数组。

二维数组的数组名，也是数组名，数组名就是数组首元素的地址

arr -首元素的地址-第一行的地址-一维数组的地址-数组的地址

所以还可以这样写

void Print(int (*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}

在循环体中，使用了两个指针的间接引用 *(*(p + i) + j)。这里 p 是一个指向二维数组的指针，(p + i) 指向二维数组中的第 i 行。然后，*(p + i)  取得该行的地址，并加上 j，得到某一行某一列元素的地址。最后，通过 *(*(p + i) + j) 取得该元素的值。

其实，在一维数组传参过程中，形参既可以写成数组的形式，又可以写成指针的形式，因为本质上这两种方式都是传递的是数组首元素地址，是互等的。int arr[]和int arr*等价

同理，二维数组传参也有两种方式：

1. 形参也是使用二维数组的形式。
2. 形参使用数组指针的形式。
3. 二维数组的行可以省略列不能省略，所以也可以写arr[][5]

练习：

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];

arr 是一个能够存放5个整型数据的数组。
parr1 是一个数组，能够存放整型指针的数组，数组大小为10，数组每个元素是整形
parr2 是一个指针，指向元素为10的数组，每个元素的类型是int*
parr3 是一个数组，数组有10个元素，指向一个指针，指针指向的内容是元素为5的数组，每个元素的类型是int，即是一个存放数组指针的数组。

详细讲一下第三个：

这个声明 int (*parr3[10])[5]; 定义了一个名为**parr3的数组**，它包含了 10 个指向长度为 5 的整型数组的指针。

具体来说，(*parr3[10]) 表示一个指针数组，其中 * 表示指针的解引用操作符，也即 (*parr3) 表示指针数组内的元素类型为指针。而 [5] 则表示指针所指向的数组被定义为长度为 5 的整型数组。

因此，parr3 是一个包含 10 个元素的指针数组，每个元素都是一个指向长度为 5 的整型数组的指针。可以通过 parr3[i] 来访问指针数组中的元素，在通过 *parr3[i] 解引用指针，可以获取指针所指向的长度为 5 的整型数组。

实际上，使用这种形式的情况并不太常见。指针数组可以在某些特定的编程场景中被用到，但是int (*parr3[10])[5];这个特定的类型定义可能相对较罕见。

---

4. 数组参数、指针参数

1. 一维数组传参

数组传参数组接受（因为形参不会真的创建一个数组所以可以省略个数，本质上传递的指针）所以第一个正确，第二个也正确，第三个也正确，

第四个也正确数组传递用数组接收。

最后一个因为arr2是指针数组每一个元素都是int*类型，数组名是首元素的地址，所以是int*的地址那就是二级指针

---

2.二级数组传参

可以省略行数但是不能省略列数，所以第一个ok，第二个不行，第三个ok。

第四个也不行，因为二维数组的数组名是一行的地址。

第五个是指针数组，不行

第六个是数组指针，ok

第七个是二级指针，只能用来来接收一级指针，而arr是一行的地址。

---

3.一级指针传参

一级指针传参，形参就写成一级指针就行。、

#include <stdio.h>
void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", *(p + i));
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p，传给函数
	print(p, sz);
	return 0;
}

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

其实都是地址（指针）&变量名，指针，数组名，接收的时候使用的的形参要对应。

---

4 二级指针传参

#include <stdio.h>
void test(int** ptr)
{
	printf("num = %d\n", **ptr);
}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);
	test(&p);
	return 0;
}

解析：

首先，在main函数中，声明了一个整型变量 n，并用指针 p 存储其地址，即 &n。然后，声明了一个指向指针的指针 pp（也就是说pp是二级指针），将其指向 p 的地址，即 &p。

接下来，调用了 test 函数两次，分别传入 pp 和 &p。

在test函数中，形参 ptr是指向指针的指针。通过使用 **ptr，可以获取到每个指针所指向的值。

首先，在第一次调用 test(pp) 中，pp 作为实参传递给 ptr。**ptr 相当于对 pp 进行了两次解引用，即得到了指针 p 指向的值 n。因此打印出 num = 10。

在第二次调用 test(&p) 中，&p 作为实参传递给 ptr。同样，**ptr 相当于对 &p 进行了两次解引用，即得到了指针 p 指向的值 n。因此也打印出 num = 10。

当函数的参数为二级指针的时候，可以接收什么参数？

本质上都是二级指针，一级指针的地址，二级指针，指针数组的数组名。

---

5. 函数指针

类比一下：

前面的数组指针-指向数组的指针

那么函数指针-指向函数的指针

&函数名就得到了函数的地址。思考一下&数组名得到的是数组的地址，数组名是数组的首元素的地址，那函数名是不是也是函数的地址呢。

函数名是函数的地址，&函数名也是函数的地址,即&Add和Add等价

问题来了，用一个变量来存放函数的地址，这个变量的类型怎么写呢？

int (*pf)(int, int) = &Add;//pf是函数指针变量
//int (*)(int, int) 是函数指针类型

解析：一个指针 pf，它指向一个函数，该函数的返回类型是 int，参数类型为两个 int。指针 pf 被初始化为指向函数 Add 的地址。

去掉函数名字就是函数指针的类型:int (*)(int, int) 是函数指针类型
，类比：数组指针int （*pa）[10];去掉名字pa就是这个数组指针的类型：int（*）[10];指针所指向的数组的类型就是：int  [10]

通过指针调用函数

int main()
{
	int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };

	//arr 是数组名，数组名表示数组首元素的地址

	Print(arr, 3, 5);
		
	return 0;
}

int Add(int x, int y)
{
	return x + y;
}

int main()
{
	//int (*pf)(int, int) = &Add;
	int (*pf)(int, int) = Add;

	int r = Add(3, 5);
	printf("%d\n", r);

	int m = (*pf)(4, 5);

	printf("%d\n", m);

	return 0;
}

首先定义了一个指针 pf，它是一个指向返回类型为 int，参数类型为两个 int 的函数的指针。然后使用 Add 函数的名称来初始化指针 pf，因为函数名本身就代表函数的地址，无需使用取地址操作符 &。

接着，通过直接调用函数 Add(3, 5) 来求得参数为 3 和 5 的和，并将结果存入变量 r 中。然后使用指针 pf 来间接调用函数 Add(4, 5)，并将结果存入变量 m 中。

可以看出，通过指针 pf 来调用函数 Add 的效果与直接调用函数是一样的。这种方式可以提供更大的灵活性，使得函数可以通过指针的方式进行传递和调用。

这里的（*pf）也可以直接写成pf，类比于数组指针也可以使用下标引用操作符来操作。

例如，对于一个整型指针数组int* pa = arr，你可以使用*(pa+1)或者pa[1]来访问数组的第二个元素。

所以，“(pf)(4, 5)”和“pf(4, 5)”之间的等价关系与“(pa+1)”和“pa[1]”之间的等价关系是相似的。它们都是使用不同的语法来达到相同的目的。

有趣的两段代码

(*(void (*)())0)();

void (*)()              —— 函数指针类型
( void (*)() )0         —— 对0进行强制类型转换，转换成这种类型 void (*)() 的函数指针。即将地址0当做存放函数指针的地址。
(*( void (*)() )0 )()  —— 通过函数指针调用函数，函数的参数为空。
即上面的代码实在调用0地址处的函数，这个函数没有参数，返回值是void。

即上面的代码实现调用0地址处的函数，这个函数没有参数，返回值是void。

2、

void (*signal(int , void(*)(int)))(int);

解析：

这是一个函数原型的声明，表示了一个函数signal，该函数接受两个参数。第一个参数是整型，第二个参数是一个指向接受整型参数并返回void的函数的指针。该函数signal将返回一个指向接受整型参数并返回void的函数的指针。

下面对这个函数原型进行详细解释：

1. 函数名：signal
   自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）

PO等大厂，18年进入阿里一直到现在。**

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-2vMNsR8C-1713714060715)]

[外链图片转存中…(img-AlzYekXO-1713714060716)]

[外链图片转存中…(img-NUI2JPEW-1713714060717)]

[外链图片转存中…(img-Zj4IcVkT-1713714060718)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）