指针数组 
 

 首先从名字就可以知道这是一个数组，是存放指针的数组。
 

 先看几种指针数组：
 

 
 
int *arr1[10];
char *arr2[5];
char **arr3[6];
因为 [ ] 的优先级是高于 * 的，所以数组名会先于 [ ] 相结合组成数组。 再于 int * / char *类型结合，组成存放该类型的数组。
 

 
 
 
 

 
 
 

 
 
 
 

 指针数组因为存放的都是指针所以不管是 int *   char * 还是 char ** 其大小都是四个字节。
 
 
 

 
 
 
数组指针 
 
从名字看就知道是指针，是指向一个数组的指针。
 
 
int (*p)[10];
char (*p)[10];
由数组指针知道 [ ] 的优先级是高于 *  的，所以用（）来提升指针先结合。 
 
 
int (*p)[10];  //  是一个指向10个整形的一维数组的指针
char (*p)[10]; //  是一个指向10个字符型的一维数组的指针
 
 
数组的存储方式
 


 

 
因为指向的是一个数组，所以大小由数组决定 

 
 
函数指针
 

 指向函数的指针，通俗的说也就是函数的地址
 

 
void(*pfun)();
 
 

  pfun 先和*结合，说明pfun是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void
 
 
 

  也就是说 其可以保存函数的地址
 
 
 

 
 
 

 
 
 

 
 
 
函数指针数组
 

 
int (*parr[3])();
 parr先与 [ ]结合，说明是一个数组，再与*结合，说明数组存放的是指针，指针都指向的是函数
 

 函数指针数组的使用（转移表）
 

 例子：计算器
 

 
#include<stdio.h>

int add( x, y)
{
	return x + y;
}
int sub(x,y)
{
	return x - y;
}
int mul(x,y)
{
	return x * y;
}
int div(x,y)
{
	return x / y;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*parr[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
	while (input)
	{
		printf("*******************************\n");
		printf("***** 1.add         2.sub *****\n");
		printf("***** 3.mul         4.div *****\n");
		printf("*******************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input > 0 && input < 5))
		{
			printf("输入你要计算的数：\n");
			scanf("%d  %d", &x, &y);
			ret = (*parr[input])(x, y);
		}
		else
			printf("输入有误！\n");
		printf("%d\n", ret);
	}
	return 0;
}
 

 输出结果：
 

 
 
 

 
 
 
指向函数指针数组的指针 
 
这是一个指针，指向一个数组，这个数组是一个函数指针数组，数组中的元素都是函数指针
 
定义方式：
 
 
#include<stdio.h>
void test(const char *str)
{
	printf("%s\n", str);
}
int main()
{
	void (*pfun)(const char*) = test;
	//函数指针pfun
	void (*pfunArr[5])(const char* str);
	//函数指针的数组pfunArr
	void (*(*ppfunArr)[10])(const char* str) = &pfunArr;
	//指向函数指针数组pfunArr的指针ppfunArr
	return 0;
}

 

 
 

 
 

一.函数指针
 
1.定义理解
 函数指针：是一个指针，存放函数地址的指针。
 函数的地址可以通过取地址函数名拿到，也可以通过函数名直接拿到。
2.函数指针
 （1）定义一个函数test
 
void test(char *str)
{
    printf("%s\n",str);
}
int main()
{
    //函数指针的定义方式
    void (*p)(char *str) = test;
    return 0;
}
 
（2）函数指针的使用
 
//调用函数test，传参：zhangsan
(*p)("zhangshan");
 
这里的*没有起作用，它是让我们知道这是一个指针然后解引用了一下。所以可以简化一下：（下面的写法也正确）
 
p("zhangsan");
 
（3）一些函数指针举例
 
//add函数
int (*p)(int x,int y)=add；
//调用
p(2,3);
//sub函数
int (*p)(int x,int y)=sub；
//调用
p(2,3);
 
这些函数指针类型都相同，因此我们考虑能不能把这些函数指针放到一个数组中呢？接下来我们引入一个函数指针数组。
 
二.函数指针数组
 
1.定义理解
 存放相同类型函数指针的数组。
2.函数指针数组
 定义一个函数指针数组
 
int (*p[4])(int,int)={add,sub,mul,div};
//该函数指针数组包含四个函数指针
//分别指向add函数，sub函数，mul函数，div函数
//每一个函数的参数都是两个int型的参数
 
调用函数
 
//调用add函数
P[1](8,4);--->输出12
//调用sub函数
P[2](8,4);--->输出4
//调用mul函数
P[3](8,4);--->输出32
//调用div函数
P[4](8,4);--->输出2
 
三.指向函数指针数组的指针
 
1.定义理解
 针对刚刚上面存放了add，sub，mul，div四个函数的地址的指针数组p，既然p是一个数组，那么我们可以对p进行取地址，取出来的是数组的地址，要将这个地址存放起来我们需要一个指针，我们称作指向函数指针数组的指针。
2.函数指针数组的指针
 那么函数指针数组的指针该如何书写呢？ 
 我们还是以上面的函数指针数组p为例。
 
int (*(*pp)[4])(int x,int y)=&p;
//这里的pp就是存放了函数指针数组p的指针
 
小总结
 
到这里为止大家可能对这些比较绕，我们来总结一下。 
①函数指针int (*p)(int , int); 
 （这是一个指针，指向一个函数） 
②函数指针数组int (*p[4])(int ,int) 
 （这是一个数组，数组有四个元素，每个元素是一个指向函数的指针） 
③指向函数指针数组的指针int (*(*p)[4])(int ,int) 
 （这是一个指针，指向一个数组，这个数组有四个元素，每个元素是一个指向函数的指针
  

在C语言中，指针是一个很重要但是又很容易弄错的概念，也可以说指针就是C语言的灵魂，所以说学好指针对于完全掌握C语言是一个必须的过程。而在指针中，指针函数、函数指针、指针函数数组、函数指针数组、指向函数指针数组的指针等等概念看着又绕又头疼。本问总结了一下以上一些概念以及用法，并给出例程深化理解。
 
1. 指针函数
 
指针函数就是返回指针值的函数，本质是一个函数。所以指针函数等价于“返回值为指针的函数”。
 
声明形式：type *func (参数列表)
 
#include <iostream>
using namespace std;


int *GetNum(int x); //指针函数声明形式


void main(void)
{
    cout << "===============start================" << endl;
    int num;
    cout << "Please enter the number between 0 and 6: ";
    cin >> num;
    cout << "result is:" << *GetNum(num) << endl;    //输出返回地址块中的值
    system("pause");
}

int *GetNum(int x) {
    static int num[] = { 0,1,2,3,4,5,6 };
    return &num[x];  //返回一个地址
}
 
2. 函数指针
 
函数指针就是一个指向函数的指针。每个函数在编译时，会被分配一个入口地址，一般用函数名来表示，这个地址就是该函数的指针。
 
声明形式：type (*func)(参数列表 )
 
从上面的定义形式可以看出，函数指针和指针函数的直观上区别在于指针符号*与函数名/指针名有没有用括号（）包裹起来，从这一点来看是很容易区分两者的。
 
#include <iostream>
using namespace std;

int max(int a, int b) {
    return a>b ? a : b;
}

void main(void)
{
    cout << "===========start===========" << endl;
    int(*func)(int, int);       //定义一个指向该函数形式的指针变量
    func = max;
    int a, b;
    cout << "Please enter two numbers:";
    cin >> a >> b;
    cout << "max=" << (*func)(a, b) << endl;    //运用指针变量调用函数
    cout << "max=" << max(a, b) << endl;        //使用原函数调用
    cout << "max=" << func(a, b) << endl;       //使用函数指针名调用，func = max
    system("pause");
}
 
上例给出了函数指针的两种最普遍的调用形式，一个是直接用定义的指针变量(* func)调用，一个是用指针名调用，后者看起来就像是将原函数使用了新名称去调用一样，可以看成函数的别名。再次强调一下：指针变量名和指针符号 * 一定要用括号包裹起来。函数指针还有一种常用的使用方式，就是使用typedef定义后再使用。将上例稍作修改如下：
 
#include <iostream>
using namespace std;

int max(int a, int b) {
    return a>b ? a : b;
}

typedef int(*func)(int, int);

void main(void)
{
    cout << "===========start===========" << endl;
    func maxfunc = max;
    int a, b;
    cout << "Please enter two numbers:";
    cin >> a >> b;
    cout << "max=" << (*maxfunc)(a, b) << endl; //运用指针变量调用函数
    cout << "max=" << max(a, b) << endl;        //使用原函数调用
    cout << "max=" << maxfunc(a, b) << endl;        //使用函数指针名调用，func = max
    system("pause");
}
 
3. 函数指针数组
 
顾名思义，就是每个元素都是函数指针的数组，直接在函数指针名后面加上数组符号[ ]即可。
 
声明形式：type (*func[ ])(参数列表 )
 
#include<iostream>
using namespace std;

void fun1()
{
    cout << "调用函数fun1" << endl;
}
void fun2()
{
    cout << "调用函数fun2" << endl;
}
void fun3()
{
    cout << "调用函数fun3" << endl;
}
int main()
{
    //定义三个函数指针
    void(*pfun)() = &fun1;
    void(*pfun2)() = &fun2;
    void(*pfun3)() = &fun3;
    //接下来就是定义一个数组把他们三个装进去。
    void(*pfunarr[3])();
    void(*pfunarr[3])();
    pfunarr[0] = pfun;
    pfunarr[1] = pfun2;
    pfunarr[2] = pfun3;
    /*  或者这样赋值
    pfunarr[0] = &fun1;
    pfunarr[1] = &fun2;
    pfunarr[2] = &fun3;
    */
    //调用运行
    pfunarr[0]();
    pfunarr[1]();
    pfunarr[2]();
    /*  或者这样调用
    (*pfunarr[0])();
    (*pfunarr[1])();
    (*pfunarr[2])();
    */
    system("pause");
    return 0;
}
 
4. C语言函数不可以定义为数组，只能通过函数指针来操作定义函数指针数组。
 
5. 指向函数指针数组的指针
 
声明形式：type (* (*func )[ ])(参数列表 )
 
#include<iostream>
using namespace std;

void fun1()
{
    cout << "调用函数fun1" << endl;
}
void fun2()
{
    cout << "调用函数fun2" << endl;
}
void fun3()
{
    cout << "调用函数fun3" << endl;
}
int main()
{

    //void(*pfun)() = &fun1;
    //void(*pfun2)() = &fun2;
    //void(*pfun3)() = &fun3;
    //接下来就是定义一个数组把他们三个装进去。
    void(*pfunarr[3])();
    void(*(*pfunarr2)[3])();
    //在这里呢看着个指针数组，他就是一个具有3个以函数指针为内容的元素的函数指针数组。
    pfunarr[0] = &fun1;
    pfunarr[1] = &fun2;
    pfunarr[2] = &fun3;

    pfunarr2 = &pfunarr;
    (*pfunarr2)[0]();
    pfunarr[0]();
    system("pause");
    return 0;
}
 
分析其定义形式：void(*(*pfunarr2)[3])() 
 其中(* pfunarr2)[3]表示数组指针，而void(* )( )表示函数指针，两者结合起来就是指向函数指针数组的指针。

数组指针
 
概念：数组指针是指针，只要是指针他就占4个字节；
 
例如： 整形指针：int *p;能够指向整形数据的指针
 
   浮点型指针：float *p;能够指向浮点型的数据的指针
 
那么数组指针，同样的理解就是指向数组的指针。
 
Eg:  int (*p)[10]
 
解释：这里的p由于小括号的原因和*先结合，所以他就是指针，然后指向的是一个大小为10的整形数组，所以p首先是一个指针，然后指向一个整形数组，即p的名字叫做数组指针。
 
使用：
 
Int arr[10] = {0};
 
此时：arr表示：数组首元素的地址
 
  &arr 表示：数组的地址
 
我们运行下面一段代码，得到结果如图：
 

 
 
arr代表数组的第一个元素，所以打印出数组第一个元素的地址
 
  arr+1代表数组第一个元素向后加一个，得到了的第二个元素，因为是整形数组，所以，地址加了一个4
 
 &arr+1:因为&arr代表的是整个数组的地址，所以在+1之后，代表的是下一个数组的地址。
 
 
 
指针数组
 
根据数组指针是指针的理解，我们可以得到，指针数组就是数组，其数组的元素都是指针。
 
Eg:一个以为指针数组的定义：int *p[10];
 
因为[]的结合优先级比较高，所以p先和[]结合
 
指针数组常用来指向字符串，方便字符串的处理
 
数组参数 和  指针参数
 
一维数组的传参：
 

 
 
没有报错，说明图中的传参方式都可以作为一维数组的传参方式
 
二维数组的传参：
 
 
 
当运行这段代码的时候，会出现第一个函数的报错，提示缺少下标，当我们在一个函数的参数的第二个中加上二维数组的列数：5，则编译通过，说明二维数组在传参的过程中是必须要传列数的。
 
一级指针传参
 
当一个函数的参数部分是一级指针的  时候，那么此时我们可以给参数传进去一个地址，因为指针里面就是地址，也可以传进去一个指针，此时编译都可以通过，所以，我们在一定的程度上就可以把：地址=指针
 
二级指针传参
 

 
 
在运行如图代码之后，test函数的参数就是接收一个二级指针，在调用的时候，第一次直接传进去一个二级指针：调用成功。因为二级指针里面存放的是一个一级指针的地址，所以我们在第二次调用的时候，传进去一个一级指针的地址&p，显示调用成功，所以：函数的参数是二级指针的时候，可以接收一个二级指针或者一级指针的地址作为参数。
 
 
 
函数指针
 
首先运行一段代码：
 

 
 
可以看到test 和&test的值是一样的，所以此时，我们就可以把test看作是函数的地址，
 
 
 
阅读一下代码帮助理解：
 
Void  test(){
 
Printf(“hehe\n”);
 
}
 
//void (*p1)()
 
//void *p2() 
 
此时只有p1可以存放函数test的地址，p1先和*结合，说明p1是指针，指针的指向是一个函数，指向的这个函数没有参数，返回值的类型是void。
 
 
 
函数指针数组：
 
首先它是一个数组，存放的元素是指针，这些指针都指向某个函数。
 
则其定义为： 
 
例如：int (*parr1[10])()
 
首先parr1先和[]结合，他就是数组，那么数组的内容就是int (*)()类型的函数指针
 
错误实例： int *parr1[10]()×
 
         int (*)()parr3[10] ×
 
函数指针数组的用途：转移表
 
 在我们设计一个计算器的时候：
 
 
 
我们用函数指针数组，将加减乘除四个函数存放起来，
 
调用时，我们可以：*pcal[1](3,2),此时我们将调用add函数进行3和2 加运算
 
 
 
函数指针数组的指针
 
既然数组可以用指针指，叫做数组指针，那么函数指针数组也可用指针指起来，叫做：函数指针数组的指针，顾名思义，这个指针指向了一个数组，这个数组叫做函数指针数组，数组里面的元素存放的是函数的指针，这些函数的指针，分别的指向了特定的函数。
 
如何定义：
 
Void test (const char *str){}
 
Int main(){
 
//定义函数指针pfun
 
Void (*pfun)(const char *) = test;
 
//函数指针的数组pfunarr
 
Void (*pfunarr[5])(const char *str)；
 
//函数指针数组的指针
 
//void (*(*pfunarr[5]) )(const char *) = &pfunarr;
 
Return 0;
 
} 
 
函数指针的应用：回调函数
 
例如：
 
Int test(void *str1,void *str2){}
 
void fun(int x,const char* str,int(*funname)(void *,void*)){
 
//函数体内部会调用第三个参数传进来的函数，返回值是int，有两个参数，都是void型
 
}
 
Int main(){
 
Fun(a,str,test);//此时test函数就当做参数传递到fun函数里面
 
Return 0
 
}