【C进阶】指针（二）

r囧r小猫 2023-10-15 18:26 32阅读 0赞

**目录**

六、函数指针数组

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

八、回调函数

1.回调函数

2.qsort快排：

3.使用回调函数，模拟实现qsort（采用冒泡的方式）

（1）参数1：void\*base（数组）

（2）参数2：size\_t num（数组中元素的个数）

（3）参数3：size\_t size（每个元素的大小）

（4）int （\*cmp）（const void\*e1,const void \*e2) (函数指针）

（5)cmp（（char\*）base+j\*size，（char\*）base+（j+1)\*size)（比较对象的地址）

（6）swap函数交换

--------------------

### 六、函数指针数组 ###

数组是一个存放相同类型数据的存储空间，我们已经学习了指针数组

eg：

> int \*arr\[10\] //整形指针数组-数组-存放的是整形指针
> 
> char \*arr\[5\] //字符指针数组-数组-存放的是字符指针

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

> int （\*parr【10】）（ ）

parr先和【】结合，说明parr是数组，那么数组的内容是什么呢？

是int（\*）（）类型的函数指针（从**函数指针+数组名【】**）

**总结：**

> **看pa和【】还是和\*结合，**
> 
> **如果是和【】结合,那么pa就是数组**
> 
> **如果是和\*结合，那么pa就是指针**

eg：函数指针数组可以将类型为函数指针的元素放在一起

int Add(int x, int y)
    {
    	return x + y;
    }
    int Sub(int x, int y)
    {
    	return x - y;
    }
    int main()
    {
    	int (*pf1)(int, int) = &Add;
    	int (*pf2)(int, int) = &Sub;
    	//数组中存放相同类型的多个元素
    	int (*pfArr[2])(int, int) = { &Add,&Sub };
    	//pfArr是函数指针数组-存放函数指针的数组
    	return 0;
    }

**函数指针数组的用途:转移表**

eg2：（计算器）

基础版：但是这个代码不好，如果想实现||，&&，&，|，>>,<<更多的功能还得重复写一些步骤，就很冗余

#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 menu()
    {
    	printf("***********************************\n");
    	printf("***1.add       2.sub***************\n");
    	printf("***3.mul       4.div***************\n");
    	printf("***0.exit *************************\n");
    	printf("***********************************\n");
    
    }
    int main()
    {
    	int x, y = 0;
    	int input = 0;
    	int ret = 0;
    	do
    	{
    		menu();
    		printf("请选择:\n");
    		scanf("%d", &input);
    		switch (input)
    		{
    		case 1:
    			printf("请输入2个操作数：\n");
    			scanf("%d %d", &x, &y);
    			ret = add(x, y);
    			printf("ret=%d\n", ret);
    			break;
    		case 2:
    			printf("请输入2个操作数：\n");
    			scanf("%d %d", &x, &y);
    			ret = sub(x, y);
    			printf("ret=%d\n", ret);
    			break;
    		case 3:
    			printf("请输入2个操作数：\n");
    			scanf("%d %d", &x, &y);
    			ret = mul(x, y);
    			printf("ret=%d\n", ret);
    			break;
    		case 4:
    			printf("请输入2个操作数：\n");
    			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;
    }

**使用函数指针数组实现：**

这样就统一起来了，更加简洁，方便，如果要加功能，只需要改菜单，数组定义，input的范围

#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 menu()
    {
    	printf("***********************************\n");
    	printf("***1.add       2.sub***************\n");
    	printf("***3.mul       4.div***************\n");
    	printf("***0.exit *************************\n");
    	printf("***********************************\n");
    
    }
    int main()
    {
    	int x, y = 0;
    	int input = 1;
    	int ret = 0;
    	int (*p[5])(int, int) = { NULL,&add,&sub,&mul,&div };//转移表(加个NULL是为了和数组下标统一）
    	while (input)
    	{
    		menu();
    		printf("请选择:\n");
    		scanf("%d", &input);
    		if (input == 0)
    		{
    			printf("退出程序\n");
    		}
    		else if (input <= 4 && input >= 1)
    		{
    			printf("请输入2个操作数：\n");
    			scanf("%d %d", &x, &y);
    			ret = (*p[input])(x, y);//*可不写，和函数指针一样
    			printf("ret=%d\n", ret);
    		}
    		else
    		{
    			printf("输入错误，请重新输入\n");
    		}
    	}
    
    	return 0;
    }

> **注意**：这样改的条件是：**函数的返回类型和参数类型一样**

--------------------

### 七、指向函数指针数组的指针 ###

（这部分内容不重要，但是可以拓展视野）

类比：指向指针数组的指针 int\*（\*p）【3】=&arr

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

eg：

> int（\***（\*p）****【5】**）（int，int）=&pfArr p是指向函数指针数组的指针
> 
> int（\* **【5】**）（int，int）=&pfArr 函数指针数组类型
> 
> int（\* ）（int，int）=&pfArr 函数指针类型

--------------------

### 八、回调函数 ###

##### 1.回调函数 #####

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

简单来说就是有两个函数，通过函数指针得到一个函数A（回调函数）的地址， 另一个函数

B（&A）实现间接调用A函数

> **注意：**依赖**函数指针**才有回调函数

eg1：

计算器基础版简化：

这个部分每个case都在重复，那就用一个函数进行代替：

case 1:
    			printf("请输入2个操作数：\n");
    			scanf("%d %d", &x, &y);
    			ret = add(x, y);//sub/mul/div
    			printf("ret=%d\n", ret);
    			break;

运用回调函数进行改进：

#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 menu()
    {
    	printf("***********************************\n");
    	printf("***1.add       2.sub***************\n");
    	printf("***3.mul       4.div***************\n");
    	printf("***0.exit *************************\n");
    	printf("***********************************\n");
    
    }
    void calc(int (*pf)(int,int))
    {
    	int x, y = 0;
    	printf("请输入2个操作数：\n");
    	scanf("%d %d", &x, &y);
    	int ret = pf(x, y);
    	printf("ret=%d\n", ret);
    }
    int main()
    {
    	int input = 0;
    	do
    	{
    		menu();
    		printf("请选择:\n");
    		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;
    }

图解：

![983429fcb99644cc9e067bcf809ae4f5.png][]

借助calc函数回调add，sub，mul，div等函数，是通过函数地址回调函数，逻辑就是进入case语句calc函数开始执行，当执行到ret=pf（x，y），又回调add等函数，回调结束又回到calc函数中

> **注意：add，sub，mul，div这些函数才是回调函数**，而不是calc函数

--------------------

eg2：

##### **2.qsort快排：** #####

对数据的排序方法有很多：冒泡排序，选择排序，插入排序，快速排序

为了对比qsort函数进行排序我们这里再来复习一下冒泡排序：

#include<stdio.h>
    void print_arr(int* arr, int sz)
    {
    	for (int i = 0; i < sz; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    }
    void bubble_arr(int* arr, int sz)
    { 
    	for (int i = 0; i < sz-1; i++)//趟数
    	{
    		for (int j = 0; j < sz-i-1; j++)//每一趟冒泡排序
    		{
    			if (arr[j] > arr[j + 1])
    			{
    				int tmp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = tmp;
    			}
    		}
    	}
    }
    int main()
    {
    	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	print_arr(arr, sz);
    	bubble_arr(arr, sz);
    	print_arr(arr, sz);
    
    	return 0;
    }

但是这个冒泡排序只能排序int类型的数据，下面就来介绍qsort快排：

> qsort函数是一个**库函数**，底层使用的**快速排序**的方式，对数据进行排序，这个函数**可以直接使用**，可以用来**排序任意类型的数据**
> 
> 头文件：**\#include<stdlib.h>**
> 
> **void qsort( void \*base, size\_t num, size\_t width, int (\_\_cdecl \*compare )(const void \*elem1, const void \*elem2 ) );**
> 
> **qsort（被排序数组的初始位置，要排序的数组的元素个数，一个元素所占字节，比较函数）**

重点是最后一个参数，比较函数：

如果要升序(elem1<elem2),则return<0，就要return elem1-elem2

如果要降序(elem1>elem2),则return>0，就要return elem2-elem1

#include<stdio.h>
    #include<stdlib.h>
    int int_cmp(const void* e1, const void* e2)
    {
    	return (*(int*)e1 - *(int*)e2);
    }
    int main()
    {
    	int arr[] = { 1,3,5,7,9,2,4,6,8,0 };
    	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), int_cmp);
    	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    	return 0;
    }

> 比较不同类型的数据，方法是有差异的：
> 
> （1）排序整形数据，两个整形可以直接直接使用><比较
> 
> （2）比较结构体数据，两个结构体的数据**可能**不能使用>比较
> 
> （eg：字符串的比较得用strcmp）

> **注意：**比较函数(\_\_cdecl \*compare )的返回值一定为**int类型**
> 
> 比较函数就是回调函数，比较时没有直接用比较函数(\_\_cdecl \*compare )，而是通过函数指针传给qsort函数

为什么用void\*类型的指针 ？

> **void\*指针：无具体类型的指针**
> 
> **不能进行解引用操作，也不能进行+-整数的操作**
> 
> **它是用来存放任意类型数据的地址的**

结构体类型数据快排：

//结构体类型
    struct Stu
    {
    	char name[20];
    	int age;
    };
    
    //int cmp_stu_by_age(const void* e1, const void* e2)
    //{
    //	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
    //}
    //int cmp_stu_by_name(const void* e1, const void* e2)
    //{
    //	return *(struct *)e1 - *(int*)e2;
    //}
    
    int cmp_stu_by_name(const void* e1, const void* e2)
    {
    	return strcmp(((struct Stu*)e1)->name , ((struct Stu*)e2)->name);
    }
    int main()
    {
    
    	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 12} };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    
    	//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
    
    	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name)；
    
    	return 0;
    }

double类型的数据快排：这两种都可以

//浮点型数据
    int cmp_double(const void* e1, const void* e2)
    {
    	return (int)(*(double*)e1 > *(double*)e2);
    }
    //int cmp_double(const void* e1, const void* e2)
    //{
    //	return *(double*)e1 < *(double*)e2?-1：1 ;
    //}

--------------------

#####  **3.使用回调函数，模拟实现qsort（采用冒泡的方式）** #####

如果像下面这样正常方法，的确是冒泡排序的方式，但是只能比较int类型的数据，而且没有回调函数

void bubble_sort(int arr[], int sz)
    {
        //冒泡排序的趟数
    	for (int i = 0; i < sz - 1; i++)
    	{
            //一趟冒泡排序
    		for (int 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;
    			}
    		}
    	}
    }

**下面来改改bubble\_sort函数的参数：**

###### （1）参数1：void\*base（数组） ######

第一个参数int \*arr肯定不行，要是想比较结构体等其他类型的数据，那就考虑像qsort函数一样传void\*base（void\*类型的指针，无具体类型的指针，这样可以存放任意类型的地址）

###### **（2）参数2：size\_t num（数组中元素的个数）** ######

第二个参数还是数组中元素的个数（size\_t num)，确定趟数等时候需要

**(size\_t类型表示C中任何对象所能达到的最大长度，它是无符号整形）**

**（头文件：\#include<stddef.h>）**

###### （3）参数3：size\_t size（每个元素的大小） ######

由于要对每个元素进行比较，如果只有两个参数不知道怎么**取出下一个元素**，那就需要给出第三个参数每个元素的大小（size\_t size)

###### （4）int （\*cmp）（const void\*e1,const void \*e2) (函数指针） ######

由于结构体的比较不能用< >比较，所以引入参数函数指针**int （\*cmp）（const void\*e1,const void \*e2)** (e1和e2分别是两个指针，存放一个要比较的元素的地址）

> e1指向的元素>e2指向的元素，返回>0的数字
> 
> e1指向的元素==e2指向的元素，返回0
> 
> e1指向的元素<e2指向的元素，返回<0的数字

###### （5)**cmp（（char\*）base+j\*size，（char\*）base+（j+1)\*size)（**比较对象的地址） ######

有了比较函数，那么怎么将arr【j】的和arr【j+1】的地址给e1和e2，如果是int类型的arr，那么先将void\*base转化为int \*类型，再加上j，即arr【j】的地址为（int \*）base+j\*size，但是如果是char类型的数组或者是结构体，那么又要改

为了统一，我们采用最小单元（char \*），也就是将void\*base强制转化为char \*类型，然后再+j\*size，那么最后比较就是**cmp（（char\*）base+j\*size，（char\*）base+（j+1)\*size))**

###### （6）swap函数交换 ######

如果if条件中的比较函数为真，那么就需要交换进行比较的元素，以前的int tmp肯定不行，如果要交换其他类型的数据，那么就考虑写个**swap函数，把交换元素的地址传进去**

那怎么交换元素呢，为了统一可以考虑**一个字节一个字节（char\*）的进行交换**，并且用for循环控制结束，直到走完元素总字节数结束循环，因为不同类型数据所占的字节数不同，而且传参传的是地址，那么就需要将数据的size传进来，即swap（char\* buf1 ，char\* buf2，size\_t size)

**完整的代码如下：**

#include<stddef.h>
    #include<stdio.h>
    void swap(char* buf1, char* buf2,size_t size)程序员写的内部逻辑
    {
    	for (int i = 0; i < size; i++)
    	{
    		char tmp = * buf1;
    		*buf1 = *buf2;
    		*buf2 = tmp;
    		buf1++;
    		buf2++;
    	}
    }
    void bubble_sort(void*base, size_t num, size_t size,int (*cmp)(const void*e1,const void*e2))//程序员写的内部逻辑
    {
    	for (int i = 0; i < num - 1; i++)
    	{
    		for (int j = 0; j < num - 1 - i; j++)
    		{
    			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
    			{
    				swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
    			}
    		}
    	}
    }
    void print_arr(int *arr,int sz)
    {
    	for (int i = 0;i < sz; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    }
    int cmp_int(const void* e1, const void* e2)//自己使用时写的
    {
    	return (int*)e2 - (int*)e1;
    }
    void test1()
    {
    	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	print_arr(arr, sz);
    	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    	print_arr(arr, sz);
    }
    struct Stu
    {
    	char name[20];
    	int age;
    };
    int cmp_stu_by_name(const void* e1, const void* e2)
    {
    	return strcmp(((struct Stu*)e1)->name ,((struct Stu*)e2)->name);
    }
    int cmp_stu_by_age(const void* e1, const void* e2)
    {
    	return (((struct Stu*)e1)->age -( (struct Stu*)e2)->age);
    }
    void test2()
    {
    	struct Stu arr[] = { {"zhangsan",20},{"list,30"},{"wangwu",15} };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
    	//bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
    
    }
    int main()
    {
    	//测试bubble_sort排序整型数据
    	//test1();
    	
    	//测试bubble_sort排序结构体数据
    	test2();
    	return 0;
    }

--------------------

本次内容就到此啦，欢迎评论区或者私信交流，觉得笔者写的还可以，或者自己有些许收获的，麻烦铁汁们动动小手，给俺来个一键三连，万分感谢 !

![03929da8396b438f984b7e04bf01680e.jpeg][]

[983429fcb99644cc9e067bcf809ae4f5.png]: https://img-blog.csdnimg.cn/983429fcb99644cc9e067bcf809ae4f5.png
[03929da8396b438f984b7e04bf01680e.jpeg]: https://img-blog.csdnimg.cn/03929da8396b438f984b7e04bf01680e.jpeg