c语言--指针进阶（3）函数指针数组、指向指针数组的指针、回调函数

眼镜蛇学习编程

已于 2023-08-18 17:46:28 修改

阅读量75

点赞数

文章标签： c语言数据结构算法学习考研

于 2023-08-18 17:40:04 首次发布

本文链接：https://blog.csdn.net/m0_61402375/article/details/132344758

版权

回顾函数指针（加补充讲解）

我们之前讲的函数指针案例回顾

#include<stdio.h>
int Add(int x,int y)
{
    int z=0;
    z=x+y;
    return z;
}
int main()
{    
    int a=10;
    int b=20;
    int (*p)(int,int)=Add;   //(*p)说明p是个指针，后面（int，int）说明p后面是函数，
                              //函数类型是int
    
	printf("%d\n",(*p)(2,3)); //（1）p是个指针,*p解引用，找到那个函数Add，然后调用函数Add，传参过去
    printf("%d\n",Add(2,3));  //（2）
	printf("%d\n",p(2,3));    //（3）上面代码int (*p)(int,int)=Add;将Add传给p，就相当于p和Add作用就一样了，
	                             // Add本来就是函数名，而函数名表示是地址，调用就是函数地址调用，
	                             //现在把Add传给p所以，p也是地址了，用地址调用函数

	//上面三种调用效果一样，
	return 0;
}

（1）printf("%d\n",(*p)(2,3));

注意如果加了*，必须括起来，这样(*p) ：p先和（）结合在调用就对了

如果写成printf("%d\n",*p(2,3)); ，由于（）优先级比*高，先执行调用p(2,3)，结果是5，然后*5就会出现问题

解释：p是个指针,*p解引用，找到那个函数Add，然后调用函数Add，传参过去

（2）printf("%d\n",Add(2,3));

解释：熟悉的函数调用，Add本来就是函数名，而函数名表示是地址，调用就是函数地址调用

（3）printf("%d\n",p(2,3));

解释：上面一行代码 int (*p)(int,int)=Add; 将Add传给p，就相当于p和Add作用就一样了，Add本来就是函数名，而函数名表示是地址，调用就是函数地址调用。现在把Add传给p所以，p也是地址了，用地址调用函数

（1）（2）（3）上面三种调用效果一样，运行结果如图

函数指针数组

数组是一个存放相同类型数据的存储空间，我们已经学了指针数组，（指针数组：它是个数组，里面存放着指针）

如下面代码：arr是数组，有10个元素，每个元素类型是int*型

int *arr[10]; 
//数组的每个元素是*int

定义-函数指针数组

如果把函数的地址存放到一个数组中，那么这个数组就是函数指针的数组，

那么如何定义函数指针的数组呢？

int(*parr1[10])();  //正确
int  *parr2[10]();  //错误
int (*)() parr3[10]; //错误

（1）int(*parr1[10])();

===>parr[10],是个数组，有10个元素，parr为数组名

===>去掉后数组内容是什么呢？是int(* )()；剩下这个是类型（函数指针），一个指针* ，外面是个（）是个函数，函数无参，返回类型是int

===>所以是函数指针类型的数组

（2）int *parr2[10]();错误

（3）int (*)() parr3[10];错误

案例学习函数指针数组

//函数指针数组
#include<stdio.h>
int Add(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 Sub(int x,int y)
{
	return x-y;
}


int main(){
	//指针数组
	int * arr[5];
	//上面4种函数，函数名不同，即地址不同，但是都是函数类型是个地址。同时上面函数参数类型和返回类型都是int一样的。
	//所以需要一个数组，这个数组可以存放4个函数地址，就是函数指针的数组
	
	int (*pa)(int,int)=Add;//现在定义一个函数指针变量去调用，将Add传过去，调用加法
	                       //同理pa里面也可以存Sub/Mul/Div，这几个函数地址都可以存，所以需要一个存放函数地址的数组
	
	int (*parr[4])(int,int)={Add,Sub,Mul,Div};//parr就是函数指针的数组

	//使用函数指针数组
	int i=0;
	for(i= 0;i<4;i++)
	{
		printf("%d\n",parr[i](2,3));//依次调用4个函数
	}
	return 0;
}

分析

运行结果

练习

已知 char* my_strcpy(char* dest,const char* src);

（解释代码：返回类型是char*，函数名字是my_strcpy，函数形参是char* dest和const char* src）

问题：

//1.写一个函数指针pf，能够指向my_strcpy
//2.写一个函数指针数组pfArr，能够存放4个my_strcpy函数的地址

#include<stdio.h>

char* my_strcpy(char* dest,const char* src);

int main()
{
	//1.写一个函数指针pf，能够指向my_strcpy
	char* (*pf)(char* ,const char*);

	//2.写一个函数指针数组pfArr，能够存放4个my_strcpy函数的地址
	char* (*pfArr[4])(char*,const char*);
	return 0;
}

函数指针数组的用途

函数指针数组的用途：转移表

案例（计算器）

#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 x=0;
	int y=0;
	//利用函数指针数组，存放不同函数的地址
	//pfarr是一个函数指针数组
	int(*pfArr[])(int,int)={0,Add,Sub,Mul,Div};
	int ret;
	do
	{
		menu();
		printf("请选择：>");
		scanf("%d",&input);
		if(input>=1 && input<=4)
		{

			printf("请输入两个操作数：>");
	        scanf("%d%d",&x,&y);
			int ret=pfArr[input](x,y);
			printf("%d\n",ret);
			
		}
		else if(input ==0)
		{
			printf("退出\n");
		}
		else
		{
			printf("选择错误\n");
		}	

	}while(input);
}

运行结果

指向函数指针数组的指针

指向函数指针数组的指针是一个指针，指针指向一个数组，数组元素都是函数指针

回调函数

回调函数可以解决代码冗余的问题

上面的计算器可以用回调函数写

//使用回调函数 
#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;
}

void Calc(int(*pf)(int,int))

{
	int x=0;
	int y=0;
	printf("请输入两个操作数：>");
	scanf("%d%d",&x,&y);
	printf("%d\n",pf(x,y));
}

int main()
{
	int input = 0;
	
	do
	{
		menu();
		printf("请选择：>");
		scanf("%d",&input);
		switch(input)
		{
		case 1:
			Calc(Add);
			break;
		case 2:
			Calc(Sub);
			break;
		case 3:
			Calc(Mul);
			break;
		case 4:
			Calc(Div);
			break;
		case 0:
			printf("退出\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}

	}while(input); 
}

用简单代码学习回调函数

#include<stdio.h>

void print(char* str)
{
	printf("hehe:%s\n",str);
}
void test( void(*p)(char*) )
{
	printf("test\n");
	p("bit");
}
int main()

{
	test(print);
}

分析：