指针的进阶

当我们对指针的普通理解后，我们就要开始深入了解指针，以及学会指针的应用。

首先我们先了解一下指针数组。

什么是指针数组呢？ 就是我通过字面意思可以了解指针数组就是存放指针的数组（以指针为元素的指针数组）

int* arr[] = {0};
char* p[] = NULL;

这两种的初始化方式都可以。

既然有指针数组那么也应该有数组指针，我们同样可以通过字面意思了解，就是指向数组的指针。

形如

int arr[5] = {0};
int (*p)[5] = &arr;

我们先对数组指针的简单的了解，我们要想深入了解首先我们要了解数组名和首元素地址的关系.。

 我们看1和2，可以看到&arr和arr的地址是相同的，当时当我们各自加一后数组就变得不一样了

3：004FF95C

4:   004FF968

我们可以看见我们其实就相加16，同时我们在关注一下arr数组，arr数组每个元素是4个字节，一共有4个字节，那么总共就16字节。所以当我们&arr+1时我们就跳过了整个数组的地址。那么我们就能很清楚的知道其实&arr指向的是整个数组的。同时我们的数组指针也是指向整个数组的指针。

我们再分析一下数组指针。

char arr[5] = {0};
char (*p)[5] = &arr;//数组指针
char *p[5] = {arr};//指针数组

我们首先分析数组指针，首先*与p先结合表示了这是个指针，这时，可以简化为 char (*)[5]=&arr;

这个时候我们就可以知道，这个指针是指向一个char类型有五个元素的数组。

我们再看指针数组,首先p与[5]结合代表我们首先是一个数组同时这个数组的类型是char* 类型的。

我们了解完数组指针，和指针数组，我们了解一下应用。

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

在这里我们用到了指针来打印，但是我们很难用数组指针来进行应用，如果硬用，也会显得非常的别扭。形如：

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

但是其实，数组指针并不常用于一维数组，更多的用于二维数组。我们来看看数组指针在二维数组中的应用。

int main()
{
	int arr[3][3] = { {0,1,2},{1,2,3},{2,3,4} };
	int(*p)[3] = &arr;
	int i = 0;
	int j = 0;
 	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 3; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
	return 0;
}

*（p+i）相当于拿到了二维数组的第i行，也相当于第i行的数组名

数组名表示首元素的地址，其实也是第i行第一个元素的地址

p是第一行的地址

p+i是第i行的地址

*（p+i)是第i行的第i行第一个元素的地址

学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：

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

1.一个有五个int类型的元素的数组。

2.首先parr1与[10]先结合，同时再与int *结合，这样就是一个有10个元素为int*类型的数组。

3.首先*先与parr2先结合就变成了一个指针，这个指针指向一个有10个int类型的元素的数组。

4.parr3先于[10]结合，说明parr3是一个数组，数组是10个元素，数组的每个元素类型是int（*）[5]

该类型的指针指向一个有五个元素为int类型的数组。

#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr)//ok?
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

 咱们先对text(arr)进行分析：

1.我们用数组传参用数组接受完全没问题。不写[]内的数字也没有问题

2.过

3.我们用数组传参，用指针接收也可以，我们用数组传参其实就是传的就是地址，数组名表示首元素地址，把首元素的地址传过去，在用指针接受地址，同时类型也一样。

咱们再看看text2，arr2首先是一个指针数组，所以arr2也是一个地址

1.传过去数组，在用数组接收没有问题，类型相同，没有问题

2.arr2中每个元素都是int*类型，所以用二级指针int**接收没有问题

一维数组我们看完了，我们再看看二维数组

void test(int arr[3][5])//ok？    1
{}
void test(int arr[][])//ok？      2
{}
void test(int arr[][5])//ok？     3
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//ok？         4
{}
void test(int* arr[5])//ok？      5
{} 
void test(int (*arr)[5])//ok？    6
{}
void test(int **arr)//ok？        7
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}

1.传指针，用指针接收没有问题，类型，大小也相同

2.出现明显错误，把数组名传过去，其实就是传来了一个地址，我们用数组接受时，列数没有写，这样会导致数无法正常排序,形参的二维数组行可以省略，但是列不能省略。

3.用数组接受，同时标清楚列，ok

4.二维数组本质上也是数组，数组名也是首元素地址，首先这个是为二维数组的类型就是int(*)[5]所以用int*类型接收就不可取。

5.这里的形参的类型就是int *[5],是一个指针数组，传过去一个指针，用一个数组接受，显然是不合理的。

6.传过去一个数组指针，用数组指针接收。ok.

7.用一个二级指针接收不合理！

一级指针传参
 

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

看完这个代码，我们需要思考：当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

一般来说，我们都是传指针，我们就用指针接收。

二级指针传参
 

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

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

---

函数指针

看完数组指针我们再看看函数指针。

函数指针其实就是指向一个函数的指针。

函数的地址就是存放函数的地址。

#include<stdio.h>
int add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*pa)(int, int) = add;
	int sum = (*pa)(2, 3);
	printf("%d", sum);
	return 0;
}

首先，这个我们看看这个函数指针是怎么创建的。

首先（*pa）表明一个指针

（*pa）（int,int)表示这个函数有两个参数，都是int类型的。

int （*pa)(int ,int)表示这个函数指针的返回类型也是int类型的。

我们再把add的函数名，也就是函数的地址赋值给这个函数指针，这样我们就完成了这个函数指针的创建和初始化。

int (*pa)(int ,int) = add;

同时我们用int sum = (*pa)(2,3);来完成函数指针的调用。（实际上*不带也可以）

---

我们来阅读两端有趣的代码。

//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);

代码1：

首先我们先看内部void（*）（）这个就是一个函数指针类型，函数类型是void，无参。

再把这个函数指针括起来和0结合就是将这个0强制转换成一个地址

把0强制转换成一个void (*)()类型的函数指针

同时在调用0地址处的函数。

代码2：

首先函数signal是一个函数声明signal有两个参数.

其中一个时int类型的，另一个时void(*)(int)类型的函数指针，signed的返回类型也是一个函数指针，该指针指向的一个函数参数为int类型。
返回类型时void.

所以signed的类型就是void(*)(int).

---

函数指针数组

函数指针数组是存放函数指针的数组。我们来看一段代码：

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int (*pasmd[4])(int, int) = { Add,Sub,Mul,Div };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = (*pasmd[i])(8, 4);
		printf("%d\n", ret);
	}
	return 0;
}

这就是函数指针。