1. AI技术聚合首页
  2. IT

【C语言】函数指针|函数指针数组|函数指针数组指针|如何理解？

心中带点小风骚 • • IT • 阅读 39

目录

1.函数指针

1.1函数指针定义

数组指针：指向数组的指针

类比数组指针，可以得到函数指针：指向函数的指针

以下我们以加法函数Add为例讲解函数指

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int a = 3;
	int b = 5;
	int ret = Add(a, b);
	
	return 0;
}

上述为一个加法函数Add，我们使用Add(a,b)调用，可以得到a+b的结果

我们已经知道如何定义一个数组指针

int arr[10] = {1,2,3,4,5,6,7,8,9,0}

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

类比数组指针，我们定义一个函数指针pf：

int (*pf)(int int) = &Add：pf指向函数Add

定义一个函数指针后，我们如何使用呢？ 

如下图所示：我们使用*pf(a,b)和pf(a,b)都可以调用成功

因为函数名和pf一样都可以表示函数的地址，Add(a,b)可以成功调用，pf(a,b)同理

 1.2使用函数指针实现简单计算器

以下代码是我们最初的构想：

#include<stdio.h>
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 meau()
{
	printf("********** 0.exit ********\n");
	printf("******1.Add    2.sub******\n");
	printf("******3.mul    4.div******\n");
	printf("**************************\n");

}
int main()
{
	int input = 0;
	int a = 0;
	int b = 0;
	int result = 0;
	do
	{
		meau();//调用菜单函数
		printf("请选择要执行的操作>\n");
		scanf("%d", &input);
		
		switch (input)
		{
		case 0:
			printf("退出计算\n");
			break;
		case 1:
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			result = Add(a, b);//执行加法
			printf("结果是：%d\n", result);
			break;
		case 2:
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			result = sub(a, b);//执行减法
			printf("结果是：%d\n", result);
			break;
		case 3:
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			result = mul(a, b);//执行乘法
			printf("结果是：%d\n", result);
			break;
		case 4:
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			result = div(a, b);//执行除法
			printf("结果是：%d\n", result);
			break;
		default:
			printf("输入错误，重新输入>\n");
			break;
		}
	} while (input);
	

	return 0;
}

 以下是程序运行结果：

以上代码可以实现加减乘除简易计算器的计算，但是我们可以发现在switch-case语句中存在大量的代码冗余，我们应当尽量避免这种写法，所以我们使用函数指针来改进：

冗余代码：

printf(“请输入俩个操作数>\n”);
scanf(“%d %d”, &a, &b);
result = Add(a, b);//执行加法

printf(“结果是：%d\n”, result);

对于冗余的代码，我们可以把它封装成一个函数calc：

函数的返回类型是viod，因为我们已经在函数内部进行了结果的打印

那函数的参数是什么呢？

不难发现，冗余代码中只有调用的函数不同，所以我们的参数应该和函数有关才可以调用

如何找到一个函数，那当然就是通过函数指针啦

所以参数就是一个函数指针，并且这个指针指向的函数们返回类型类型，参数都一致

定义如下：

void calc(int* pf(int, int))
{
	printf("请输入俩个操作数>\n");
	scanf("%d %d", &a, &b);
	result = pf(a, b);//函数调用
	printf("结果是：%d\n", result);
}

有了calc函数，只需要在case语句中调用calc函数，并传参数为标号所对应的函数名即可

具体实现如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
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 meau()
{
	printf("********** 0.exit ********\n");
	printf("******1.Add    2.sub******\n");
	printf("******3.mul    4.div******\n");
	printf("**************************\n");

}
void calc(int* pf(int, int))
{
	int a = 0;
	int b = 0;
	printf("请输入俩个操作数>\n");
	scanf("%d %d", &a, &b);
	int result = pf(a, b);//执行加法
	printf("结果是：%d\n", result);
}
int main()
{
	int input = 0;
	do
	{
		meau();//调用菜单函数
		printf("请选择要执行的操作>\n");
		scanf("%d", &input);

		switch (input)
		{
		case 0:
			printf("退出计算\n");
			break;
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		default:
			printf("输入错误，重新输入>\n");
			break;
		}
	} while (input);


	return 0;
}

可以实现计算器的效果 

2.函数指针数组

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

上述程序只能实现加减乘除四则运算，当我们需要实现更多的功能，例如x&y，x|y，x>>y，x<<y等一系列高级功能时，我们可以使用函数指针数组，以下还是以上个程序为基础介绍

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
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 meau()
{
	printf("********** 0.exit ********\n");
	printf("******1.Add    2.sub******\n");
	printf("******3.mul    4.div******\n");
	printf("**************************\n");

}
int main()
{
	int input = 0;
	meau();	
	int (*parr[10])(int, int) = { 0,&Add,&Sub,&Mul,&Div };
	//多组输入
	do
	{
		printf("请输入要执行操作的序号\n");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算\n");
		}
		else if (input >= 1 && input <= 4)
		{
			int a = 0;
			int b = 0;
			printf("请输入俩个操作数>\n");
			scanf("%d %d", &a, &b);
			int result = parr[input](a, b);//函数调用
			printf("结果是：%d\n", result);
		}
		else
		{
			printf("输入错误，请重新输入\n");
		}
	} while (input);
	
	return 0;
}

首先我们参照整型数组理解一下函数指针数组

 

代码分析：

int (*parr[10])(int, int) = { 0,&Add,&Sub,&Mul,&Div };

//parr是一个函数指针数组

//为了使我们的输入与数组下标相对应，方便代码书写，0也参与数组的初始化
//当input == 0时执行，退出计算

if (input)

{
    printf(“退出计算\n”);
}

//当输入我们需要执行的操作的合法标号时执行
else if (input >= 1 && input <= 4)
{
    printf(“请输入俩个操作数>\n”);
    scanf(“%d %d”, &a, &b);
    int result = parr(input)(a, b);//函数调用

    //当input == 1时，result = parr[1] = &Add(a,b) = Add(a, b)

    //因为&Add和Add都表示函数的地址，所以这里可以完成函数调用
    printf(“结果是：%d\n”, result);
}

//输入其他非法数字时执行
else
{
    printf(“输入错误，请重新输入\n”);
}

3.函数指针数组指针

函数指针数组指针，顾名思义，就是指向函数指针数组的指针

首先，我们需要定义一个函数指针数组，如下

int (*pfarr[5])(int, int) = { 0 };

接着定义一个指针，指向这个数组

对于一个整型数组int arr[5] = { 0 };指向它的指针如下图所示

对于一个函数指针数组指针，首先它是一个指针，指向的数组有5个元素，每个元素的类型是int  (*) (int,int)

4.回调函数

4.1回调函数的定义

回调函数就是一个通过函数指针调用的函数。如果把一个函数指针（即函数的地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数，回调函数不是用该函数的实现方直接调用，而是在特定条件或者条件发生时由另外的一方调用的，用于对该事件或者条件的响应。

在上述使用函数指针实现计算器的例子中，类似calc(Add),calc(Sub)就是回调函数 

4.2库函数qsort的使用

库函数qsort：使用快速排序的思想实现的一个排序函数

我们使用cplusplus官网可以检索这个函数

官网地址：cplusplus.com – The C++ Resources Network

通俗来说，就是对于一个每个元素都是size类型的数组，我们从base指针指向的那个数开始，向后的num个数，按照compar指定的比较方式进行比较

 关于compar:首先这是一个函数指针，它指向的函数就是进行比较

可以这么认为：我们传给compar函数俩个参数a和b，compar函数处理并按照返回规则（如上图）返回一个整型数据，这个返回的数据作为库函数qsort函数的参数，qsort按其默认的顺序（默认升序）进行排序

另外，可以发现qsort函数和compar函数的参数类型都是const viod*类型，而不是某个具体的类型：其中，const用来保护数据，防止误操作造成程序错误

对于void*：viod*是一个没有具体类型的指针(可以称之为泛型指针)，可以接收任意类型的指针,因为函数提前不知道我们要操作的数据的类型,使用泛型指针，提高了函数的通用性

当然，泛型指针的特殊性导致其不能直接进行解引用操作，也不能进行+/-整数的操作

当我们使用时，需要先强制类型转换为我们需要的数据类型，再解引用操作

接下来我们使用qsort函数实现对结构体数据数据的排序

首先定义一个结构体类型，结构体成员变量包括了姓名，性别(male/female),年龄

struct Stu
{
	char name[10];
	char sex[10];
	int age;

};

接着我们在main函数中创建一个结构体数组进行初始化

int main()
{
	//结构体变量定义
	struct Stu s[] = { {"zhangsan","female",19 },{ "lisi","male",20 }, 
					   { "wangwu","female",18 },{ "zhouliu","male",20 } };
	//打印
	printf("%-10s %10s %10s\n", "姓名", "性别", "年龄");
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%-10s %10s %10d\n", s[i].name, s[i].sex, s[i].age);
	}
	return 0;
}

printf(“%-10s %10s %10s\n”, “姓名”, “性别”, “年龄”);

%10s是一种打印格式：字符串占位符10位，默认右对齐

%-10s可以设置成左对齐

可以打印一下定义的结构体变量，检查赋值有无错误

然后使用sqort函数对结构体变量的成员排序

我们在主函数中加入俩行代码：

一行计算数组元素个数，即我们需要排序的元素个数

一行是qsort函数的调用，参数分别为：

  1. s：数组名即数组首地址，这里即表示我们从数组的第一个元素开始排序
  2. sz：数组的元素个数，这里表示需要排序的元素个数即为整个数组所有元素
  3. sizeof(s[0])：计算一个数组元素的大小，这里即表示待排序元素的大小
  4. compar_by_name：这是一个函数的地址，这个函数就是我们的比较方式
int main()
{
    //结构体变量定义
    int sz = sizeof(s) / sizeof(s[0]);//计算数组元素的个数
    qsort(s, sz, sizeof(s[0]), compar_by_age);
    //打印
}

接下来我们分别书写通过年龄，姓名和性别进行比较的函数 

  • 按照年龄排序
//年龄升序排列
int compar_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
	//*p1>*p2 返回>0
	//*p1==*p2 返回==0
	//*p1<*p2 返回<0

}
  • 按照姓名排序
//姓名的字符串升序排列
int compar_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}

因为strcmp函数的返回值刚好和比较函数的返回值符号相一致，所以我们可以不进行if语句的判断，直接将strcmp函数的返回值返回即可； 

  • 按照性别排序
//性别的字符串升序排列
int compar_by_sex(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->sex, ((struct Stu*)p2)->sex);

}

综上分析，我们可以写出以下完整代码

#define _CRT_SECURE_NO_WARNINGS 1//这行代码是避免VS编译器报scanf函数不安全的错误
#include<stdio.h>
#include<stdlib.h>//库函数qsort所需要的头文件
#include<string.h>
struct Stu
{
	char name[10];
	char sex[10];
	int age;

};
//年龄升序排列
int compar_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
//姓名的字符串升序排列
int compar_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
//性别的字符串升序排列
int compar_by_sex(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->sex, ((struct Stu*)p2)->sex);

}
int main()
{
	//结构体变量定义
	struct Stu s[] = { {"zhangsan","female",19 },{ "lisi","male",20 },
					   { "wangwu","female",18 },{ "zhouliu","male",20 } };
	int sz = sizeof(s) / sizeof(s[0]);//计算数组元素的个数
	qsort(s, sz, sizeof(s[0]), compar_by_age);
	//按其他方式比较只需要改变函数指针compar_by_age即可

	//打印
	printf("%-10s %10s %10s\n", "姓名", "性别", "年龄");
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%-10s %10s %10d\n", s[i].name, s[i].sex, s[i].age);
	}
	return 0;
}

4.3模拟qsort实现冒泡排序

 冒泡排序的基本原理我们已经讲解过，具体参考

https://mp.csdn.net/mp_blog/creation/editor/123819688

模拟qsort函数，所以我们的冒泡排序函数参数应与其一致

接下来我们进行函数传参

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	//这是一个降序数组，我们通过冒泡排序将其升序排列
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0], cmp));
	//打印
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

bubble_sort(arr, sz, sizeof(arr[0], cmp));

其中，cmp 函数就是我们的比较函数

我们先编写 bubble_sort函数

和之前实现的冒排序函数一样，我们使用双层循环实现

不同的地方就是我们使用一个比较函数进行比较，如果不符合升序，则交换

交换也通过swap函数实现

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void*, const void*))
{
	int i = 0;
	//外层循环控制冒泡排序的趟数
	for (i = 0; i < sz; i++)
	{
		int flag = 1;//默认数组有序
		int j = 0;
		//内层循环控制每一趟冒泡排序
		for (j = 0; j < sz - 1 - i; j++)
		{

			//比较之后发现前数大于后数，则交换两个元素
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0))
			{
				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
				flag = 0;//进行了交换，数组乱序则flag置为0
			}
		}
		//一次冒泡排序中没有进行交换，则数组有序,跳出循环
		if (flag == 1)
		{
			break;
		}

	}
}

 接着编写cmp比较函数

int cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);//升序排列，降序排列交换p1和p2即可
}

最后编写swap交换函数

void swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

注：关于cmp函数的参数和swap函数的参数

cmp(  (char*)base + j * width,  (char*)base + (j + 1) * width)

传参时，首先对base指针进行了强制类型转换，将base指针进行细化，使其可以每次访问一个字节（方便了char型数据的排序）；然后我们给它加了一个偏移量j+width，我们知道width是一个元素的大小，循环时，j从j=0开始，所以第一次比较函数比较的是(char*)base和(char*)base+width(整型数组时，width == 4);第二次比较函数比较的是(char*)base+width和(char*)base+2*width(整型数组时，width == 4)…我们画图解释

每次加一个偏移量使指针指向我们比较的位置 

如果不符合升序排列，就进行交换，调用swap函数

swap函数按每次访问一个字节的方式交换，因为我们在cmp函数中对指针进行了细化，所以这里每次交换一个字节，当元素为整型数据时，我们需要循环四次依次交换四个字节的数据

综上所述，整体代码如下

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

int cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
//swap函数按字节为单位交换两个元素
void swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void*, const void*))
{
	int i = 0;
	//外层循环控制冒泡排序的趟数
	for (i = 0; i < sz; i++)
	{
		int flag = 1;//默认数组有序
		int j = 0;
		//内层循环控制每一趟冒泡排序
		for (j = 0; j < sz - 1 - i; j++)
		{

			//比较之后发现前数大于后数，则交换两个元素
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
				flag = 0;//进行了交换，数组乱序则flag置为0
			}

		}
		//一次冒泡排序中没有进行交换，则数组有序,跳出循环
		if (flag == 1)
		{
			break;
		}

	}
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	//这是一个降序数组，我们通过冒泡排序将其升序排列
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp);
	//打印
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

输出如下：可以实现升序排列

 

版权声明：本文为博主作者：李斯啦果原创文章，版权归属原作者，如果侵权，请联系我们删除！

原文链接：https://blog.csdn.net/m0_64538862/article/details/128668576

共计人评分，平均分

到目前为止还没有投票！成为第一位评论此文章。

赞 (0)
心中带点小风骚的头像心中带点小风骚普通用户
0
上一篇 2024年1月11日
下一篇 2024年1月11日

相关推荐