前言：总篇章分为（1）和（2），本篇内容包括：指针数组，数组指针，&数组名与数组名的区分

数组传参 ，函数指针，函数指针数组

part 1：指针数组

指针数组是存放指针的数组

int* arr1[10]; //整形指针的数组——数组10个元素，每个元素的类型是整型指针int*
char *arr2[4]; //一级字符指针的数组——数组4个元素，每个元素的类型是字符指针char*
char **arr3[5];//二级字符指针的数组——数组5个元素，每个元素的类型是二级字符指针

part 2：数组指针 

数组指针是指向数组的指针

int (*p)[10];   数组指针

解释：p先和*结合表明p是一个指针，指向一个数组，数组10个元素，每个元素的类型是int

数组指针的使用：比如打印一个二维数组

void print_arr(int(*arr)[5], int row, int col)
{int i = 0;for (i = 0; i < row; i++){int j = 0;for (j = 0; j < col; j++){printf("%d ", arr[i][j]);  // 或者：  *(*(arr+i)+j)  //  因为arr是二维数组第一行的地址，即arr指向了第一行//  arr+i:可以指向二维数组的第i行，代表的是第i行的地址// *（arr+i)就可以得到第i行的数组名//比如   int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };//int (* p)[10] = &arr;//p  --- &arr//*p --- *&arr//*p --- arr}printf("\n");}
}
int main()
{int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };print_arr(arr, 3, 5);return 0;
}

 我们知道数组指针中存放的是数组的地址

二维数组的数组名arr：数组名是数组首元素的地址，即二维数组的数组名是二维数组首元素的地址

二维数组的首元素是第一行，即第一行的一维数组

故而二维数组的数组名arr代表的是第一行的地址，即一个一维数组的地址，需要使用数组指针接收：int(*arr)[5]   

辨析指针数组和数组指针：

int arr[5];  //数组
int *parr1[10]; // 整型指针数组 - parr1是一个数组，数组10个元素，每个元素的类型是int*
int (*parr2)[10]; // 整型数组指针 - parr2是指针，指向一个数组，数组10个元素，每个元素的类型是int
int (*parr3[10])[5]; // 存放整型数组指针的数组 - parr3是数组，10个元素，每一个元素都是数组指针

part 3： &数组名与数组名的区分

数组名在绝大部分情况下是数组首元素的地址

只有两个特殊情况下，数组名代表整个数组

特殊情况1：sizeof（数组名）：此时的数组名代表整个数组，sizeof计算的是整个数组的大小

特殊情况2：&数组名：此时取出的是整个数组的地址

part 4： 数组传参

一维数组传参：

#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 - arr2是数组名，即数组首元素的地址，即int*的地址，一级指针的地址用二级指针接收
{}int main()
{int arr[10] = {0};int *arr2[20] = {0};test(arr);test2(arr2);
}

二维数组传参： 

void test(int arr[3][5])//ok
{}
void test(int arr[][])//NO  行可以省略，列不能省略
{}
void test(int arr[][5])//ok
{}
void test(int *arr)//NO arr是二维数组的数组名，是二维数组首元素（即第一行的一维数组）的地址，需要使用数组指针接收
{}
void test(int* arr[5])//NO
{}
void test(int (*arr)[5])//ok
{}
void test(int **arr)//NO
{}
int main()
{int arr[3][5] = {0};test(arr);
}

 part 5：函数指针

函数名和&函数名都是函数的地址

void test()
{printf("hehe\n");
}

存放以上函数地址的函数指针：void (*p)()

解读：p先和*结合，说明p是一个指针，p后面有（）说明p指向一个函数，函数无参，返回类型是void

当有了函数地址后，要通过函数指针对函数进行调用，可以解引用也可以不解引用

比如：

int Add(int x, int y)
{return x + y;
}
int main()
{int (* pf)(int, int) = Add;//pf是一个函数指针，指向一个函数，两个参数都是int类型，返回类型也是int类型int ret = (*pf)(3, 5); int ret = Add(3, 5);int ret = pf(3, 5);
}

 下面来阅读两个有趣的代码：

不要慌，我们慢慢分析：

代码1是对函数的调用

(* (void (*)()) 0 ) ();// void (*)()是一个函数指针类型，（类型）是强制类型转换
// 故而：
// 1 将0强制转换成void (*)()类型的函数指针
// 2 0地址处存放着一个函数，函数无参，返回类型是void
// 3 对0地址处的函数进行调用

代码2是函数的声明

void (*signal(int , void(*)(int)) )(int);
// signal后面跟着(),说明signal是一个函数，该函数的第一个参数是int类型，第二个参数是 void(*)(int)
// 除却signal(int , void(*)(int))以外，剩下的都是signal函数的返回类型：void（*）（int)

part 6：函数指针数组

函数指针数组存放的是函数指针

int (*p[10])()

解释：p先和[]结合，说明p十个数组，数组十个元素，

          每个元素的类型都是函数指针：int (*)()

函数指针数组的使用例子：简易计算器

#include<stdio.h>
void menu()
{printf("************************\n");printf("**** 1.Add 2.Sub *******\n");printf("**** 3.Mul 4.Div *******\n");printf("**** 0.exit      *******\n");printf("************************\n");
}
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 input = 0;int (*arr[5])(int , int ) = { NULL,Add,Sub,Mul,Div };int x = 0;int y = 0;int ret = 0;do{menu();printf("请选择:");scanf("%d", &input);if (input == 0){printf("退出计算器\n");break;}else if (input >= 1 && input <= 4){printf("请输入两个操作数:");scanf("%d %d", &x, &y);ret = arr[input](x, y);printf("%d\n", ret);}else{printf("选择错误，请重新选择\n");}} while (input);return 0;
}