[C++知识库] 【C语言】深入理解函数指针和函数指针数组

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> 【C语言】深入理解函数指针和函数指针数组 -> 正文阅读

[C++知识库]【C语言】深入理解函数指针和函数指针数组

文章目录

（一）什么是函数指针

（1）函数指针的定义

简单来说，是一种指向函数地址的指针。
定义函数指针语法：
返回值类型 (*指针名)(形参类型列表);
使用函数指针语法：
函数指针变量名 = 函数名;
函数指针变量名 = &函数名；

注意：

函数指针具有类型
根据所指的函数参数类型、个数、以及返回值的类型不同，所定义的函数指针类型不同
定义也可使用typedef 进行类型重命名
typedef int (*pfun)(int, int) TYPE_FUN;
TYPE_FUN 函数指针变量 = 函数名;

（2）函数指针的使用

下面简单使用函数指针，直接调用sum函数

#include <stdio.h>
int sum(int a, int b)
{
	return  a + b;
}
int main()
{
	int a =10;
	int b = 20;
	//int (*pfun)(int, int) = sum;
	int (*pfun)(int, int) = &sum;
	//printf("a + b = %d \n", pfun(a, b));
	printf("a + b = %d \n", (*pfun)(a, b));
	return 0;
}

结果：
在这里插入图片描述

（二）回调函数

（1）回调函数定义

函数形参列表中含有函数指针变量的函数叫做回调函数。

（2）回调函数的作用

通过回调函数去调用函数指针所指向的函数。

（3）回调函数的使用

众所周知，linux下的多线程的创建函数thread_create()，就是一个回调函数，下面是这个函数的声明，我们简单来看看。
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
我们可以看到函数的第三个形参void *(*start_routine) (void *)这就是一个函数指针，该函数指针形参类型是一个void*类型,函数的返回值也是void*类型
这个函数就暂时看到这…
下面我们自己编写一个回调函数，并使用它

写个冒泡排序，从小到大，从大到小两种输出结果，但只能手动调用同一个排序函数

#include <stdio.h>
//从小到大
int SmallToBig(int a, int b)
{
	return a > b ? 1 : 0;
}
//从大到小
int BigToSmall(int a, int b)
{
	return a < b ? 1 : 0;
}
void Swap(int* p, int* q)
{
	int tmp = 0;
	tmp = *p;
	*p = *q;
	*q = tmp;
}
void BubbleSort(int* arr, int len, int (*compare)(int, int))
{
	if(arr == NULL || compare == NULL || len <= 0)
		return;
	int i = 0;
	int j = 0;
	for(i = 0; i < len - 1; i++)
	{
		for(j = 0; j < len - i - 1; j++)
		{
			if((*compare)(arr[j], arr[j + 1]) == 1)
			{
				Swap(&arr[j], &arr[j + 1]);
			}
		}
	}
}

void ShowArr(int* arr, int len)
{
	if(arr == NULL || len <= 0) 
		return;
	int i;
	for(i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = {12, 22, 10, 8, 45, 26, 30, 15, 16, 12};
	int len = sizeof(arr) / sizeof(arr[0]);
	
	printf("small to big: ");
	BubbleSort(arr, len, SmallToBig);
	ShowArr(arr, len);	
	
	printf("big to small: ");
	BubbleSort(arr, len, BigToSmall);
	ShowArr(arr, len);
	return 0;
}

结果：
在这里插入图片描述

（三）什么是函数指针数组

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

（1）函数指针数组的定义

定义语法：
- 返回值类型 (*变量名[元素个数])(形参类型..) = {同类型函数名}；
- （推荐写法）typedef 返回值类型 (*函数指针变量名)(参数类型..);
  函数指针变量名数组名[元素个数];
调用函数指针数组中的函数
变量名[下标](实参列表)；

（2）函数指针数组的使用

分别写出加减乘除的四个函数，将其存放在函数指针数组中，通过数组中的元素来调用四个函数。
代码：

#include <stdio.h>
#include <limits.h>
int sum(int a, int b)
{
	return a + b;
}

int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}

int div(int a, int b)
{
	if (b == 0) return INT_MAX;
	return a / b;
}

int main()
{
	int (*pfun[4])(int, int) = { &sum, &sub, &mul, &div };

	int a = 100;
	int b = 50;
	printf("a + b = %d\n", pfun[0](a, b));
	printf("a - b = %d\n", pfun[1](a, b));
	printf("a * b = %d\n", pfun[2](a, b));
	printf("a / b = %d\n", pfun[3](a, b));

	return 0;
}

分析：我们来看看函数指针数组中的元素的类型
在这里插入图片描述
结果：

（四）函数指针实现泛型编程

（1）实现一个输出函数，输出不同类型数组中所有元素

#include <stdio.h>

void Show_Int(const void* vp)
{
	if(vp == NULL) return;
	const int* p = (const int*)vp;
	printf("%d ", *p);
}

void Show_Char(const void* vp)
{
	if(vp == NULL) return;
	const char* p = (const char*)vp;
	printf("%c ", *p);
}
void Show_Double(const void* vp)
{
	if(vp == NULL) return;
	const double* p = (const double*)vp;
	printf("%lf ", *p);
}
//arrname数组名,pfun函数指针,len数组元素个数，elemsize每个元素数据类型的大小	
void ShowArray(const void* arrname, void (*pfun)(const void*), int len, int elemsize)
{
	if(arrname == NULL || pfun == NULL || len <= 0)
		return;
	if(elemsize < 1 || elemsize > 8) 
		return;
	int i;
	const char* tmp = (const char*)arrname;
	for(i = 0; i < len; i++)
	{
		(*pfun)(tmp);
		tmp += elemsize;
	}
	printf("\n");
	
}

void Test()
{
	int arr[] = {1, 2, 3, 4, 5, 6, 7, 9, 10};
	int arr_len = sizeof(arr) / sizeof(arr[0]);
	ShowArray(arr, Show_Int, arr_len, sizeof(int));
	
	char crr[] = {'h', 'e' , 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', '\0'};
	int crr_len = sizeof(crr) / sizeof(crr[0]);
	ShowArray(crr, Show_Char, crr_len, sizeof(char));
	
	double drr[] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7};
	int drr_len = sizeof(drr) / sizeof(drr[0]);
	ShowArray(drr, Show_Double, drr_len, sizeof(double));
}

int main()
{
	Test();
	return 0;
}

结果：
在这里插入图片描述
（2）使用同一个排序函数，同一个打印函数，将int char类型的数组元素经过排序，打印。

#include <stdio.h>

void Swap_int(void* p, void* q)
{
	int tmp = (*(int*)p);
	(*(int*)p) = (*(int*)q);
	(*(int*)q) = tmp;
}
void Swap_char(void* p, void* q)
{
	char tmp = (*(char*)p);
	(*(char*)p) = (*(char*)q);
	(*(char*)q) = tmp;
}

void Swap_double(void* p, void* q)
{
	double tmp = (*(double*)p);
	(*(double*)p) = (*(double*)q);
	(*(double*)q) = tmp;
}



int Compare_int(const void* a, const void* b)
{
	return (*(int*)a) > (*(int*)b) ? 1 : 0;
}

int Compare_char(const void* a, const void* b)
{
	return (*(char*)a) > (*(char*)b) ? 1 : 0;
}

int Compare_double(const void* a, const void* b)
{
	return (*(double*)a) > (*(double*)a) ? 1 : 0;
}



void BubbleSort(void* arrname, int (*compare)(const void*, const void*), int (*pswap)(const void*, const void*), int len, int elemsize)
{
	if (arrname == NULL || compare == NULL || pswap == NULL || len <= 0 || elemsize < 1 || elemsize > 8)
		return;
	int i;
	int j;
	
	for (i = 0; i < len - 1; i++)
	{
		char* start = (char*)arrname;
		for (j = 0; j < len - i - 1; j++)
		{
			if (compare(start, start + elemsize))
			{
				pswap(start, start + elemsize);
			}
			start += elemsize;
		}
	}
}

void Show_Int(const void* vp)
{
	if (vp == NULL) return;
	const int* p = (const int*)vp;
	printf("%d ", *p);
}

void Show_Char(const void* vp)
{
	if (vp == NULL) return;
	const char* p = (const char*)vp;
	printf("%c ", *p);
}
void Show_Double(const void* vp)
{
	if (vp == NULL) return;
	const double* p = (const double*)vp;
	printf("%lf ", *p);
}


void ShowArray(const void* arrname, void (*pfun)(const void*), int len, int elemsize)
{
	if (arrname == NULL || pfun == NULL || len <= 0)
		return;
	if (elemsize < 1 || elemsize > 8)
		return;
	int i;
	const char* tmp = (const char*)arrname;
	for (i = 0; i < len; i++)
	{
		(*pfun)(tmp);
		tmp += elemsize;
	}
	printf("\n");

}

void Test()
{
	int arr[] = { 2, 1, 3, 0, 8, 5, 7, 6, 10 };
	int arr_len = sizeof(arr) / sizeof(arr[0]);
	BubbleSort(arr, Compare_int, Swap_int, arr_len, sizeof(int));
	ShowArray(arr, Show_Int, arr_len, sizeof(int));

	char crr[] = { 'h', 'e' , 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd' };
	int crr_len = sizeof(crr) / sizeof(crr[0]);
	BubbleSort(crr, Compare_char, Swap_char, crr_len, sizeof(char));
	ShowArray(crr, Show_Char, crr_len, sizeof(char));
	
	//暂不支持double，float类型的数据
	/*
	double drr[] = { 5.1, 2.4, 3.3, 1.4, 5.6, 9.6, 7.5 };
	int drr_len = sizeof(drr) / sizeof(drr[0]);
	BubbleSort(drr, Compare_double, Swap_double, drr_len, sizeof(double));
	ShowArray(drr, Show_Double, drr_len, sizeof(double));
	*/
	
}
int main()
{
	Test();
	return 0;
}