指针的进阶(2)

函数指针数组

函数指针数组的介绍

int *arr[5]所表示的是整形指针数组，而char *arr[6]是字符指针数组。

同理 函数指针数组的含义：数组中的每个元素是函数指针类型。

具体介绍之前，我们先来引入一个小的程序实现：

实现计算器的功能：

# include <stdio.h>


int Add(int x, int y)//j加法实现
{
	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 (*pf1)(int, int) = Add;
	int (*pf2)(int, int) = Sub;
	int (*pf3)(int, int) = Mul;
	int (*pf4)(int, int) = Div;
    //函数指针，分别指向加，减，乘，除四个函数。
}

如上代码所示，在主函数中用了四个函数指针，指向了实现基本运算功能的四个函数。

而像这样的代码，显得冗余复杂，我们便可以使用函数指针数组来存储调用：

int (*pfArr[4])(int, int) = { Add,Sub,Mul,Div };

这样来看，是不是显得更加精简了。

函数指针数组的定义

上短篇中最后提及的简化代码，便是函数指针数组的定义使用：

pfArr[4]

pfArr先与[4]相结合，说明pfArr是一个数组。

int (*) () 

而int (*) () 便是决定这个数组的返回类型，是int (*) ()函数类型的指针。

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

以下是普通构建计算器：

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入两个操作数：");
			scanf("%d %d", &x, &y);
				ret = Add(x, y);
			printf("ret=%d\n", ret);
			break;
		case 2:
			printf("请输入两个操作数：");
			scanf("%d %d", &x, &y);
				ret = Sub(x, y);
			printf("ret=%d\n", ret);
			break;
		case 3:
			printf("请输入两个操作数：");
			scanf("%d %d", &x, &y);
				ret = Mul(x, y);
			printf("ret=%d\n", ret);
			break;
		case 4:
			printf("请输入两个操作数：");
			scanf("%d %d", &x, &y);
				ret = Div(x, y);
			printf("ret=%d\n", ret);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		defaule:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

以下代码是使用函数指针数组构建：

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	int (*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };
	do
	{
		menu();
		printf("请选择;>");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数：");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("ret=%d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("选择错误，重新选择\n");
		}
	} while (input);
	return 0;
}

使用函数指针数组，相较于一般的代码实现，优化了多次调用函数。

指向函数指针数组的指针

指针含义

指向函数指针数组的指针是一个 指针

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

int (*pf)(int, int);//函数指针
int (*pfArr[4])(int, int);//函数指针数组
int(*(*p)[4])(int, int) = &pfArr;//指向函数指针数组的指针

回调函数

含义

函数指针的一个重大用途便是实现回调函数作用：

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

计算器示例

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

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 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);

	return 0;
}

以上代码对于计算器基础功能的实现，就是利用了回调函数，将加减乘除的函数地址作为参数，存放在Calc函数中，再通过Calc函数进行调用。避免了重复调用类型相同函数的操作。

qsort函数使用

引入

在函数一章中，我们我们认识到了冒泡排序，以下是冒泡排序的实现代码。

 	void bubble(int arr[], int sz)
	{
		int i = 0;
		
		for (i = 0; i < sz - 1; i++)
		{
			
			int j = 0;
			for (j = 0; j < sz - 1 - i; j++)
			{
				if (arr[j] > arr[j + 1])
				{
					int tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
			}
		}
	}
int main()
{
	int arr[10] = { 10,8,7,6,14,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

虽然冒泡排序可以成功实现，从代码的适用性来说，这种排序代码的实现仍有局限性：

1.当我们定义返回类型为int时，也定死了这个函数能够接受的类型，其他类型的数据将无法执行此排序操作。

2.对于整形我们使用了>或者<操作符来进行比较，但是对于不同类型数据又能否用如此简单的方式进行比较呢？

3.在数组中我们交换数据方式是对于同种数据类型，那需要交换的数据不是同一类型呢？

诸如以上缘由，我们将介绍qsort函数介绍。

qsort函数定义

在cplusplus网站中，我们找到了关于qusort的介绍：

在这里，简单介绍一下qsort的函数定义：

void qsort(void* base, //指向了需要排序的数组的第一个元素
           size_t num, //排序的元素个数
           size_t size,//一个元素的大小，单位是字节
           int (*cmp)(const void*, const void*)//函数指针类型 - 这个函数指针指向的函数，能够比较base指向数组中的两个元素
          );

在qsort 函数所使用的参数中，我们见到了void* 这种指针类型，与其他的具体返回类型的指针不同，void*没有具体的指针类型，可以接受任意类型的地址传入，但是这种类型的指针不能直接通过解引用操作,也不能用于指针的运算。

在我们需要调用的时候，需要将存入的数据强制类型转换为我们需要的数据类型(如 int)，再进行其他的操作。

int (*cmp)(const void*, const void*) 这一函数参数是一个函数指针类型，指向数组中两个需要比较元素的地址。这一函数指针需要自行构造与调用。

两个元素在这个比较函数之中，就可以确定两个元素的位置。 

模拟实现qsort

如下所示，我们将使用冒泡排序来模拟实现qsort函数功能。

冒泡函数代码：

void cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}



void Swap(char* buf1, char* buf2, int size)
{
	int i = 0;
	char tmp = 0;
	for (i = 1; i < size; i++)
	{
		tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}


void bubble_sort(void* base, int num, int size, int(*cmp)(const void*, const void*))
{
	int i = 0;
	for (i = 0; i < num; i++)
	{
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//假设需要升序cmp返回>0，交换
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

我们假定需要实现的排序数据为整形，将void*强制类型转换为char*，是因为char类型大小被定义为1字节，通过转换char*，我们可以实现对任意指针指向的地址进行访问，只需要知道我们所需类型的所占字节大小。

如果想要比较字串符的大小，在函数指针中，可以使用strcmp进行比较，其返回值同样可以应用于qsort函数参数。

对于qsort函数的学习，更加加深了对于回调函数的理解。