指针太难？手把手教你理解指针（函数、指针和数组的奇葩组合）

本文链接：https://blog.csdn.net/weixin_73577926/article/details/130152084

前言

上一篇文章详细解释了指针的传参，并理解了什么是函数指针。这篇文章将更加深入地带大家探索指针的使用。上一篇文章了解了函数指针，但是你知道函数指针数组吗？你知道什么是指向函数指针数组的指针吗？嘿嘿嘿，听起来好绕，那就让我们来看看它们到底是什么奇葩。

复习前文请跳伞👇：

指针太难？手把手教你理解指针（指针？数组？）

指针太难？手把手教你理解指针（传参、函数指针）

一、函数指针数组

1.定义

前面我们学习过指针数组，数组是存放相同类型数据的存储空间，而指针数组简单来说就是存放了一堆指针的数组。那么，函数指针数组的意义也就很明显了，就是存放了一堆函数指针的数组。那么，函数指针数组该如何定义呢？请大家动动聪明的脑袋，看看下面那个是对的：

int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];

答案是：parr1。怎么样，有没有答对呢？

parr1先和 [ ] 结合，说明parr1是个数组，这个数组元素类型是：int （*）()，也就是函数指针类型。所以，这个数组是用来存放函数指针的，故为函数指针数组。

2.使用

用函数还要使用指针？有必要这么麻烦吗？你还别说，在有些情况下，不用函数指针反而会变得麻烦。下面介绍一下函数指针数组运用的的典型场景：转移表。

举例：计算器

我们需要用c语言实现一个计算器，能够实现加减乘除四个功能。有人会说说那不是很简单吗？我直接手撕：

#include <stdio.h>
int add(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)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		printf("*************************\n");
		printf(" 1:add           2:sub \n");
		printf(" 3:mul           4:div \n");
		printf("*************************\n");
		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;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

确实，思路是非常简单的，只需要实现四个函数，返回计算之后的结果就行了。但是，你有没有发现，这些代码重复了很多次：

            printf("输入操作数：");
			scanf("%d %d", &x, &y);
			printf("ret = %d\n", ret);

接下来我们来使用函数指针数组来实现一下这个计算器，大家感受一下：

//使用函数指针数组实现
#include <stdio.h>
int add(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)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*p[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 <= 4 && input >= 1))
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
		}
		else
			printf("输入有误\n");
		printf("ret = %d\n", ret);
	}
	return 0;
}

这样以来，就连switch语句都不需要了，直接把输入的数字当作数组下标就可以调用相应的函数。

二、指向函数指针数组的指针

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

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

如何定义？

//定义指向函数指针数组的指针
void test(const char* str)
{
	printf("%s\n", str);
}
int main()
{
	//函数指针pfun
	void (*pfun)(const char*) = test;
	//函数指针的数组pfunArr
	void (*pfunArr[5])(const char* str);
	pfunArr[0] = test;
	//指向函数指针数组pfunArr的指针ppfunArr
	void (*(*ppfunArr)[5])(const char*) = &pfunArr;
	return 0;
}

三、回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

想要讲清楚这个东西怎么用，就要先了解一下库函数里面的qsort函数。qsort是一个库函数，用来排序。

qsort

void qsort (void* base, size_t num, size_t size,
            int (*compar)(const void*,const void*));

它的参数有三部分：base是要排序的元素的首元素地址，num是要排序的元素个数，size是每个元素的大小，compar是一个比较元素大小的函数的指针。这个函数需要使用者自己写。

这个函数对任何数据都可以进行排序，前提是使用者在调用时告诉这个函数，要排序的元素数量、大小、如何比较这些信息。

接下来演示一下qsort函数的使用：

#include <stdio.h>
//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int i = 0;

	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

我们可以通过模拟实现qsort的方式来使用回调函数（qsort函数采用快速排序，这里模拟实现采用冒泡排序）。模拟实现：

#include <stdio.h>

//函数实现：
//这个swap函数是bubble函数的一部分
void _swap(void* p1, void* p2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}
void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < count - 1; i++)
	{
		for (j = 0; j < count - i - 1; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

函数使用：


//函数使用：
//这个是bubble函数的使用者要自己写的函数，使用bubble函数需要把该函数传给bubble函数
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	//char *arr[] = {"aaaa","dddd","cccc","bbbb"};
	int i = 0;
	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

这样，函数bubble就通过函数指针调用了int_cmp函数，int_cmp函数就是回调函数。

到此为止，我们的指针详解就完结了。如果大家感兴趣，后面会再出一篇文章，讲解一下关于指针的典型笔试题，可以加深一下理解。