从0开始学c语言-28-qsort函数、数组和指针参数、函数指针数组（转移表）、回调函数

void test(int arr[])//ok
{}
void test(int arr[10])//ok
{}
void test(int* arr)//ok
{}
void test2(int* arr[20])//ok
{}
void test2(int** arr)//ok
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

二维数组传参

void test(int arr[3][5])//ok
{}
void test(int arr[][])//err
{}
void test(int arr[][5])//ok
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//err
{}
void test(int* arr[5])//err
{}
void test(int(*arr)[5])//ok
{}
void test(int** arr)//err
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

一级指针传参

void print(int *p, int sz) {
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d\n", *(p+i));
 }
}
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9};
 int *p = arr;
 int sz = sizeof(arr)/sizeof(arr[0]);
 //一级指针p，传给函数
 print(p, sz);
 return 0; }

当一个函数的参数部分为一级指针

的时候，函数能接收什么参数？

答案：同类型的一级指针，比如char*可以接收char[ ]数组的数组名。

（不知道答案为什么是这样的，翻到文章顶部，有链接解释）

二级指针传参

void test(int** ptr) {
 printf("num = %d\n", **ptr); 
}
int main()
{
 int n = 10;
 int*p = &n;
 int **pp = &p;
//以下这两种传参方式都可以
 test(pp);
 test(&p);
 return 0; }

思考以下代码的传参对不对？

void test(char **p) {
 
}
int main()
{
 char* arr[10];
 test(arr);//Ok?
 return 0; }

答案：OK。

arr的类型是char*[10]，指向10个char*，本质上是char**指针。

函数指针

void test()
{
	printf("hehe\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	return 0;
}

他们的输出结果（地址）是一样的，和数组名不一样的是，

函数名 == &函数名，而数组名！= &数组名。

我们监视看一下类型。

根据我们监视的结果，请看看接下来这段代码，哪个会有能力存放函数的地址呢？

void (*pfun1)();
void *pfun2();

是第一个哦，它的类型是void（*）（），是一个函数指针。

意思是说这个函数指针指向的函数，函数返回类型是void，参数没有。

而第二个，它的类型是void*（），是一个返回类型是void*的函数。

这段代码也告诉我们，如果不加（）把*和指针变量括起来，那么就会先和（）结合，解读成一个函数。

有趣的代码

(*(void (*)())0)();

猜猜这段代码的意思是？

如图：

void (*signal(int , void(*)(int)))(int);

看看这个代码的意思是？

所以

void (*signal(int , void(*)(int)))(int);
也可以写成
void(*)(int) signal(int,void（*）（int）);

简化一下代码，

typedef void(*pfun_t)(int);
//把void(*)(int)函数指针重定义为pfun_t
那么
void(*)(int) signal(int,void（*）（int）);
就可以写成
pfun_t signal(int, pfun_t);

函数指针数组

数组是一个存放相同类型数据的存储空间，

把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

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

答案是： parr1

其实最明显的，数组的标志是[ ]，函数的标志是 ()

根据这两个标志能很快判断出来类型。

parr1 先和 [ ] 结合，说明 parr1是数组名，数组指向 int (*)() 类型的函数指针，数组名

本质是int (*)() *指针，因为指向10个nt (*)() 类型的函数指针，

故parr1的类型是int (*)() [10]。

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

这是一个简答的计算器代码，分别写了加减乘除四种算法的函数，主函数用do……while循环配合switch分支来选择不同的计算方法。

#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;
}

但是太长，且有很多重复代码，这时候我们就可以用函数指针数组来完成。

最关键的一句是这个

 int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表

*p[5]其实就相当函数名，类型是int（int x,int y），函数返回类型是int，函数参数是int x和int y，这是一个函数。

p先和[5]结合，*p[5]就相当于*（p[5]）,

p[5]的类型就是在*p[5]类型中间加（*），就像这样int（*）（int x,int y），这是一个函数指针。

p的类型就是在p[5]的类型后面加[5]，就是这样int（*）（int x,int y）[5]，这是一个函数指针数组。（实际上p是指向int（*）（int x,int y）的 int（*）（int x,int y）* 指针）

当我们调用函数指针数组中的函数指针的时候，首先需要找到对应的数组下标，因为我们设置的菜单分别是1 2 3 4 来选择功能，便加了个0来让下标对上。

比如我们现在要用加法，下标是1，那么就是p[1]，p[1]是一个int（*）（int x,int y）的函数指针，要达到我们调用函数的目的还需要加上*来解引用才能完成调用，*p[1]，然后加上后面的函数参数，就像下面这样，注意一定要用（）来把*p[1]整体括起来。

(*p[1])(x, y)

但是你有没有想过一个问题，观察一下这个表达式

 int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表

我们说p的类型是int（*）（int x,int y）[5]，指向5个int（*）（int x,int y），那后面初始化的类型也应该是int（*）（int x,int y）这个函数指针才对，为什么却直接写了函数呢？

实际上我们前面提到过函数名就等于&函数名，所以函数指针当中的（*）实际上就是个摆设而已，没有实际作用，为的就是让我们好区分而已。

紧接着，我们把switch语句换成了if语句

if ((input <= 4 && input >= 1))
         {
          printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = (*p[input])(x, y); //调用函数指针
//input相当于函数指针数组中的下标
         }
          else
               printf( "输入有误\n" );
          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;
}

指向函数指针数组的指针

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

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

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; }

分析一下怎么写出来的，我们要写指向 函数指针数组 的指针

也就是说有一个指向函数指针数组的指针，这个函数指针数组中的元素都是函数指针。

那就先需要写一个函数指针，函数指针指向的是函数，就需要先写个函数，

test是函数名，它的类型是void（const char*），返回类型是void，函数参数是const char*。

void test(const char* str) {
 printf("%s\n", str);
}

现在写一个函数指针指向test函数，我们可以把*pfun看做函数名，而*pfun中的*代表的意思就是pfun是一个函数指针变量，而这个pfun函数指针指向的函数返回类型是void，函数参数是const char*。

 void (*pfun)(const char*) = test;

然后写一个函数指针数组（存放）指向5个同一类型的函数指针。我们直接在*pfunArr后面加上[5]来表示数组，因为*pfunArr[5]会相当于*（pfunArr[5]），而

*pfunArr[5]的类型是void（const char*）函数，那么

去掉*后的pfunArr[5]类型是void(*)（const char*）函数指针，再

去掉[5]后的pfunArr类型是void(*)（const char*）[5]类型，是指向 5个void(*)（const char*）函数指针的函数指针数组。

最后把pfunArr中的第一个元素初始化，这里想想为什么不是=pfun函数指针，而是=test函数本身呢？

 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;

因为函数名就等于&函数名，这就说明其实&函数名类型中的（*）其实是个摆设，没有实际作用，只是为了方便我们人为区分而已。

实际上你选择=pfun函数指针 来初始化也是一样的效果。

（或者更加离谱一些，函数本身就是指针，指向了函数返回类型和函数参数。）

终于到了我们的目的地，要写一个指向函数指针数组的指针，而被指向的函数指针数组已经写出来了，现在只需要一个指向这个对象的指针。

那当然是把(*pfunArr[5])中的 pfunArr函数指针数组名换个名字加上*再整体括起来后，ppfunArr就代表指向void(*)（const char*）[5]了。

此时 *ppfunArr 的类型是void(*)（const char*）[5]

去掉*后的ppfunArr类型是void(*)（const char*）[5] *，指向void(*)（const char*）[5] 的指针。

 void (*(*ppfunArr)[5])(const char*) = &pfunArr;

最后进行初始化等于&pfunArr。

回调函数

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

相当于高中学的复合函数，f（u（x）），将u（x）替换x。

qsort函数的使用

https://cplusplus.com/reference/cstdlib/qsort/

在这个网址中，有qsort函数的介绍。

我简单讲一下。

qsort函数是用来给数组排序的，返回类型为void（也就是说没有返回值），函数参数共有4个。

base就是需要排序的数组，

num是需要排序的元素个数（因为传递过来的数组是首元素的地址，必须要有个数才能确定排序几个元素）

size是指一个元素占几个字节的意思，（因为每个数组存放数据类型不同，char是一个字节，int是4个字节）

compare是指向返回类型为int，函数参数为两个const void*的函数指针。

qsort函数主要是通过compare进行的数组排序。

int compar (const void* p1, const void* p2);

如上图，如果compare函数的返回值<0,那么p1元素会放到p2元素后， >0则相反，=0说明p1=p2

现在演示它的使用方式

#include <stdlib.h>
int int_cmp(const void * p1, const void * p2) {
  return (*( int *)p1 - *(int *) p2);
//强制类型转换，把指针能够访问的字节变为4byte
}
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; }

可以看到的是，这个cmp函数是我们自己写的。

输出结果也达到了我们的目的，如果想升序的话，思考一下cmp函数中应该怎么写呢？

我的答案的是乘-1。

模仿qsort函数进行冒泡排序

不知道冒泡排序的看这篇文章

从0开始学c语言-16-数组以及数组传参应用：冒泡排序_阿秋的阿秋不是阿秋的博客-优快云博客

我先写了这个

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

然后在test函数中写好我们需要的大体框架。

test()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//调用冒泡排序函数
	bubble(arr,sz,sizeof(arr[0]),cmp_arr);
	//打印arr数组
	print(arr,sz);
}

把bubble函数需要的四个参数都确定好，然后写个print函数来打印排序后的arr数组。

我先写了print函数

void print(int* arr,int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
}

对比使用bubble函数和接收函数参数

为了具有通用性，所以我们选择了空指针来接收，其他的没啥好解释了。

bubble(arr,sz,sizeof(arr[0]),cmp_arr);
void bubble( void* arr,  int sz,int width, int(*cmp)(const void* e1, const void* e2) )

然后在bubble函数中写好冒泡排序的大体框架

void bubble( void* arr,  //需要排序的数组中第一个元素的地址
			 int sz,     //需要排序的元素个数
			 int width,  //一个元素的大小，单位：字节
			 int(*cmp)(const void* e1, const void* e2) 
			 //函数指针，指向了 （比较2个元素) 的函数
			)
{
	int i = 0;
	int j = 0;
	//趟
	for (i = 0; i < sz; i++)
	{
		//一趟比较
		for (j = 0; j < sz - 1 - i; j++)
		{	

		}
	}

}

现在需要确定的是，我们该如何确定一趟比较中应该交换元素的条件。

这就需要我们的 cmp函数 了，专门比较两个元素大小并返回值。

前面我们知道的 qsort函数 利用 cmp函数 传回来的三种不同范围的值来确定是否进行交换，怎么交换。

现在我们模仿 qsort函数 来写一下我们需要 用cmp函数 传回来的值干些什么。

先写一下 cmp函数，其实和 qsort函数中的 cmp函数差不多，返回两个元素相减的值（也就是判断谁大谁小）就可。

int cmp_arr(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
	//空指针不能进行解引用，所以
	//要进行强制类型转换
}

因为我们打算排序成一个升序的数组，那么，如果cmp返回一个<0的值，便需要进行交换，也就是说，需要在确定一趟比较中应该交换元素的条件中调用cmp函数把返回值带回来，那便需要确定传递过去什么参数。

我们在学习qsort函数的时候知道cmp函数是比较两个元素的，而冒泡排序中是根据arr[ j ]和arr[ j+1]来比较进行数字的交换，同样的道理我们可以把这两个参数传到cmp函数中进行比较。

但是需要知道的是，我们bubble接收数组的指针是空指针，不能进行向后挪动的操作来访问下一个元素，前面我们设置的四个参数中有表示一个元素大小的参数——width，它的单位是字节，为了方便移动，我们需要把空指针接收的数组首元素地址强制类型转换为（char*），因为char*的步长是一个字节，那么在 j变量乘上width变量后便可以表示我们需要排序的数组的一个元素大小的步长了。当然，随着j变量每次循环的增长，移动的步数也是紧挨着的，符合我们的需求。

总之：1· char*强制类型转换 2·确认好步长

if ( cmp ( (char*)arr + j * width , (char*)arr + (j + 1) * width )  < 0)

那么满足条件后便需要进行交换，这个交换函数很简单，直接上代码了

void swap( int width, char*a,char*b)
{
	//一个元素大小的交换
	int i = 0; //挪动几个字节（width
	for (i = 0; i < width; i++)
	{
		char tmp = *a;
		*a = *b;
		*b = tmp;
		a++;
		b++;
	}
}

需要传递的函数参数就交给你自己思考了哦！

是步长和两个需要交换的元素。（属于是字节为单位的交换）

现在给上完整的代码

//模仿qsort函数使用冒泡排序
int cmp_arr(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
	//空指针不能进行解引用，所以
	//要进行强制类型转换
}

void swap( int width, char*a,char*b)
{
	//一个元素大小的交换
	int i = 0; //挪动几个字节（width
	for (i = 0; i < width; i++)
	{
		char tmp = *a;
		*a = *b;
		*b = tmp;
		a++;
		b++;
	}
}
void bubble(void* arr, //需要排序的数组中第一个元素的地址
			int sz,    //需要排序的元素个数
			int width, //一个元素的大小，单位：字节
			int(*cmp)(const void* e1, const void* e2) 
			//函数指针，指向了 （比较2个元素) 的函数
			)
{
	int i = 0;
	int j = 0;
	//趟
	for (i = 0; i < sz; i++)
	{
		//一趟比较
		for (j = 0; j < sz - 1 - i; j++)
		{
			//void*是空指针，不能解引用 也不能 向前或者向后走
			//因为你不知道要访问几个字节，但是你可以往里面放任意类型的地址
			if ( cmp ( (char*)arr + j * width , (char*)arr + (j + 1) * width )  < 0)
			{
				//交换
				swap( width, ((char*)arr + j * width), ((char*)arr + (j + 1) * width));
				//传地址，让函数内外产生联系
			}
		}
	}

}
void print(int* arr,int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
}
test()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//调用冒泡排序函数
	bubble(arr,sz,sizeof(arr[0]),cmp_arr);
	//打印arr数组
	print(arr,sz);
}
int main()
{
	test();
	return 0;
}

如果还想优化，就考虑我们之前讲的assert和const来修饰一下吧。

（头文件我没给，不知道的自己查一下，https://cplusplus.com/reference/）

现在你可以看看和我们之前写的冒泡排序代码有何不同。给上链接。

从0开始学c语言-16-数组以及数组传参应用：冒泡排序_阿秋的阿秋不是阿秋的博客-优快云博客

结构体调用qsort函数

同样的道理，我们试试结构体。

首先创建一个结构体

struct Stu
{
	char name[20];
	int age;
	//结构体大小=20个char + 一个int
};

这是一个tag为Stu的结构体，结构体大小为24byte。

接下来写主函数和test函数

void test()
{
	struct Stu s [3]= { { "aqiu",9 } ,{"aka",56},{"as",4} };
	int sz = sizeof(s) / sizeof(s[0]);
}
int main()
{
	test();
	return 0;
}

在test函数中我们进行了结构体数组的初始化，并且计算了结构体数组的元素个数，这些都是为了使用qsort函数。

qsort(s, sz, sizeof(s[0]), cmp_age);

s代表结构体，sz代表结构体数组的元素个数，sizeof(s[0])代表一个结构体的大小，cmp_age是我们需要调用的函数，用来比较两个元素的大小并带回来一个返回值。

cmp_age函数的返回类型和函数参数类型都没变化，和我们上面写的不太一样的地方是，访问两个元素的方式不太一样了，因为我们是结构体元素的比较，便需要转换为结构体指针来访问结构体成员并且比较。

int cmp_age(const void* e1, const void* e2)
{
	return (((struct Stu*)e1)->age) - (((struct Stu*)e2)->age);
}

好了，调用结束。

现在我们试试比较名字来排序的cmp函数怎么写，其实道理一样的，只不过我们比较名字就是在比较字符串，比较字符串又需要使用比较字符串的函数strmp。

int cmp_name(const void* e1, const void* e2)
{
	return strcmp( ( (struct Stu*)e1 )->name, ( (struct Stu*)e2 )->name);
	//很容易括号出问题
}

同样的道理，我们把自己上面写的bubble函数中的cmp函数换成cmp_age或者cmp_name函数也可以进行结构体排序。

完整的代码太长了，bubble函数的代码就在上面，这里只给上结构体的完整代码。

#include <string.h>
#include <stdlib.h>
struct Stu
{
	char name[20];
	int age;
	//结构体大小=20个char + 一个int
};
int cmp_age(const void* e1, const void* e2)
{
	return (((struct Stu*)e1)->age) - (((struct Stu*)e2)->age);
}
int cmp_name(const void* e1, const void* e2)
{
	return strcmp( ( (struct Stu*)e1 )->name, ( (struct Stu*)e2 )->name);
	//很容易括号出问题
}

void test()
{
	struct Stu s [3]= { { "aqiu",9 } ,{"aka",56},{"as",4} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_age);
	/*bubble(s, sz, sizeof(s[0]), cmp_age);*/ 
	//bubble(s, sz, sizeof(s[0]), cmp_name);
}
int main()
{
	test();
	return 0;
}