【C语言】指针进阶（2）

小鱼儿 2023-10-13 20:54 75阅读 0赞

接上期文章指针进阶（1）[指针进阶（1）][1]

**目录**

1.函数指针

2.函数指针数组

3.指向函数指针数组的指针

4.回调函数

4.1qsort的用法

void\*类型的指针介绍

使用qsort对数组进行排序

使用qsort对结构体进行排序：

4.2使用冒泡排序算法模拟实现qsort

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

##  ##

## 1.函数指针 ##

我们已经学过了数组指针，而数组指针是指向数组的指针。根据类比的思想，我们可以推测出函数指针是指向函数的指针。

那么，如何才能得到函数的地址呢？请看下面的代码：

![319cbdb310784776964b9a268b5ba370.png][]

程序输出的两个地址是相同的：![cd7ac403f6f745a494644449d88ffa07.png][]

要想得到函数地址，可以使用&函数名或者直接函数名，使用%p的格式打印出来就可以了。

**由此我们可知：**

函数名是函数的地址

&函数名也是函数地址

如果想要将上面代码中函数的地址保存到指针变量中，那么这个指针的类型该如何书写呢？

![6d1bf717951040449026384d39730a9d.png][]

测验：写出下面函数的函数指针类型

![1bd2c7ff077e412b9c26a1f7af882e67.png][]

答案是：

![add6bdc361554325aa55a93bb70d923b.png][]

注意：\*pf的括号不能去掉，必须使\*先和pf结合。

**通过函数指针来调用该函数**

下面代码是函数指针的调用方法：

int Add(int x, int y)
    {
    	return x + y;
    }
    int main()
    {
    	int(*pf)(int, int) = Add;
    	int r = Add(3, 5);
    	printf("%d\n", r);
    
    	int m = (*pf)(3, 5);
    	printf("%d\n", m);
    
    	int n = pf(3, 5);
    	printf("%d\n", n);
    
    	return 0;
    }

打印结果：

![54089c41e7e04aaf9bf68ae9b850e148.png][]

通过上面的代码我们可以发现，pf前面的\*可以省略，实际上，**pf前面的\*只是一个摆设，无论你加多少个\*，都不会影响结果：**

![60e5ab881b1441fdbdb153f3782df73f.png][]

**阅读两段有趣的代码**：

**代码一：**

![25acb6218a234d04b1b854622f0eb4c2.png][]**分析代码：**

![b77b6728120545caa0d56275a592f76c.png][]

当然，我们写的程序是不能直接访问0地址的。

**代码二：**

![3b969c297ddc408c8d74b61c18092040.png][]

**分析代码：**![443a97bda5174f539c16ed55891ce142.png][]

## 2.函数指针数组 ##

在前面，我们已经知道了将整型指针存放在一个数组中，那么这个数组就叫做整型指针数组，像：

int\*arr\[5\] 就是一个整形指针数组。当然，还有我们比较熟悉的字符指针数组 char\*arr\[5\] .

由此，我们可以推断出，函数指针数组就是数组的每个元素是函数指针类型。

为了学习函数指针数组，我们用一个实现两个整形数字计算的程序说起：

假设有这样一个计算器，它要实现两个整数的加法，减法，乘法，除法运算：

![dd32f945378741b7983e483898ebdc44.png][]

首先，我用写了下面这几个实现上述功能的函数：

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

可以看出，这四个函数的返回类型，参数个数，参数类型都是一样的，像这种同类型的函数就可以将函数地址存放在函数指针数组中。

关键是，这个函数指针数组该怎么写呢？我们一步一步的来写：

先写出能指向这四个函数的函数指针：

![8c7ecc187f7842549c500b03bd7d85ed.png][]

要想得到函数指针数组，只需要在上面代码的基础上修改：

![5b9f921e912e4e30ae83bd87cf92a5fc.png][]

得到数指针数组只需要在函数指针名字后面加上一个 **\[ \]** 即可。

**函数指针数组实际应用场景：**  
仍然以上面的计算器为例，下面是使用**普通方法**来写一个简单的计算器程序：

#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 meun()
    {
    	printf("***********************\n");
    	printf(" 1:add           2:sub \n");
    	printf(" 3:mul           4:div \n");
    	printf(" 0:exit                \n");
    	printf("***********************\n");
    }
    
    int main()
    {
    	int input = 0;
    	int x = 0, y = 0;
    	int ret = 0;
    	do
    	{
    		meun();
    		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;
    }

使用普通方法来写代码，在switch语句中有非常多的重复部分。

下面对main函数进行修改（用到函数指针数组的方式）：

int main()
    {
    	int input = 0;
    	int x = 0, y = 0;
    	int ret = 0;
    	//函数指针数组
    	int (*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };
    	//下标                         0    1   2   3   4
    
    	do
    	{
    		meun();
    		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;
    }

## 3.指向函数指针数组的指针 ##

> 指向函数指针数组的指针这部分内容我们只需要了解即可，不需要深入研究。

在上面计算器的例子中，我们已经知道了函数指针数组的写法：

![5b9f921e912e4e30ae83bd87cf92a5fc.png][]

现在，我们想要写一个指针来指向这个函数指针数组，该怎么写呢？

只需要将数组名pfArr换成指针名p，在p的前面再加上一个\*，并用括号括起来（\[ \]的结合性比\*高）

![e1826cdd7a8c4c16a7c221621d4744e7.png][]

## 4.回调函数 ##

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

就拿上面写过的计算器来举例子，我们把main()函数再次修改：

void calc(int(*pf)(int, int))
    {
    	int x = 0, 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;
    	
    	do
    	{
    		meun();
    		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("选择错误，重新选择:>");
    			break;
    		}
    	} while (input);
    
    	return 0;
    }

我们多增加了下面这个函数，这个函数的形参是一个函数指针，用来接收Add，Sub, Mul, Div等函数。当调用calc这个函数时，calc中又会根据形参传过来的函数地址调用这个函数。这就是函数回调。

![c30085b0137b4bb985bc42aed24aec79.png][]

程序的执行过程：

![382de2c47e1e452cbce25842a21ac406.png][]

### 4.1qsort的用法 ###

在标准库中，有一个函数叫qsort，是用来排序的，qsort适合于任意类型的数据排序。

[qsort的使用说明][qsort]

### ![e67d2a86bee34d6e8ab246626c1fe478.png][] ###

### ![d1bfbd3a491f4d7d8a5a0759e3ffe5cb.png][] ###

compar的返回值所表示的内容：![55ffd981c2184a849e5db92892fedb06.png][]

####  **void\*类型的指针介绍** ####

> void\*的指针是无具体类型的指针，这种指针是不能直接解引用的，也不能直接进行运算。但它**可以接收任意类型的参数地址**，使用前要进行强制类型转换。

void\*指针接收任意类型的参数地址![5b1735de91e24d9486d04d041c50d519.png][]

####  **使用qsort对数组进行排序** ####

#include<stdio.h>
    #include<stdlib.h>
    int cmp_int(const void* p1, const void* p2)
    {
    	return *(int*)p1 - *(int*)p2;
    }
    void Print(int arr[], int sz)
    {
    	int i = 0;
    	for (i = 0; i < sz; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    }
    void test1()
    {
    	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	qsort(arr, sz, sizeof(arr[0]), cmp_int);
    	Print(arr, sz);
    }
    
    int main()
    {
    	test1();
    	return 0;
    }

####  **使用qsort对结构体进行排序：** ####

需要通过调试来观察数组的变化

#include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    //qsort排序整形数组
    struct stu
    {
    	char name[20];
    	int age;
    };
    int cmp_stu_by_age(const void* p1, const void* p2)
    {
    	return ((struct stu*)p1)->age - ((struct stu*)p2)->age;
    }
    int cmp_stu_by_name(const void* p1, const void* p2)
    {
    	return strcmp(((struct stu*)p1)->name, ((struct stu*)p2)->name);
    }
    void test2()
    {
    	struct stu arr[] = { {"zhangsan",20},{"lisi",50},{"wangwu",15} };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
    }
    int main()
    {
    	test2();
    	return 0;
    }

###    4.2使用冒泡排序算法模拟实现qsort ###

由于没有想学习快速排序算法，所以我们使用冒泡排序的思想，实现一个功能类似qsort的函数。

> 要点：
> 
> 1.使用冒泡排序算法的思想
> 
> 2.适用于任意数据类型的排序

要解决实现对任意类型数据的排序，我们接收数组的指针应该使用void\*类型。

当我们排序整形时，我们可以直接进行比较，但当我们如果要进行结构体大小比较时，就不能直接比较了，这里需要用户自己写一个比较函数来进行比较。在排序算法中以函数参数的形式传递用户写的比较函数。

在整形数组中，可以直接通过数组下标来访问数组元素，但在我们自己写的排序函数中，我们使用的void\*的指针类型，无法通过下标来访问。我们可以用下面的方式得到数组每个元素的地址：

![ca9c6d9ac7a64a61977d427ed7bd4751.png][]

不同的数据类型交换略有差异，原因是在排序函数中不知道该数据的类型，同时也是使用void\*的指针接收的地址。但是，我们是知道每个元素的字节大小的，我们只需要一字节一字节交换，交换size次，就可以实现交换功能了：

![fe0e8b19cd0b418b82f82947b1a8a1ac.png][]

代码实现交换：

![f8850fcf13f54d49b4b4c90e59d2df1c.png][]

接下来看看完整的实现代码吧：

//交换
    void swap(char* buf1, char* buf2, int size)
    {
    	int i = 0;
    	for (i = 0; i < size; i++)
    	{
    		char 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 - 1; i++)
    	{
    		int j = 0;
    		for (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);
    			}
    		}
    	}
    }

> 这篇博客就到这里结束了，下篇博客将继续学习指针，下篇博客是指针的最后一篇了，将会有大量有关指针面试题的总结，欢迎大家阅读与点赞~~

[1]: http://t.csdn.cn/aY7Qg
[319cbdb310784776964b9a268b5ba370.png]: https://img-blog.csdnimg.cn/319cbdb310784776964b9a268b5ba370.png
[cd7ac403f6f745a494644449d88ffa07.png]: https://img-blog.csdnimg.cn/cd7ac403f6f745a494644449d88ffa07.png
[6d1bf717951040449026384d39730a9d.png]: https://img-blog.csdnimg.cn/6d1bf717951040449026384d39730a9d.png
[1bd2c7ff077e412b9c26a1f7af882e67.png]: https://img-blog.csdnimg.cn/1bd2c7ff077e412b9c26a1f7af882e67.png
[add6bdc361554325aa55a93bb70d923b.png]: https://img-blog.csdnimg.cn/add6bdc361554325aa55a93bb70d923b.png
[54089c41e7e04aaf9bf68ae9b850e148.png]: https://img-blog.csdnimg.cn/54089c41e7e04aaf9bf68ae9b850e148.png
[60e5ab881b1441fdbdb153f3782df73f.png]: https://img-blog.csdnimg.cn/60e5ab881b1441fdbdb153f3782df73f.png
[25acb6218a234d04b1b854622f0eb4c2.png]: https://img-blog.csdnimg.cn/25acb6218a234d04b1b854622f0eb4c2.png
[b77b6728120545caa0d56275a592f76c.png]: https://img-blog.csdnimg.cn/b77b6728120545caa0d56275a592f76c.png
[3b969c297ddc408c8d74b61c18092040.png]: https://img-blog.csdnimg.cn/3b969c297ddc408c8d74b61c18092040.png
[443a97bda5174f539c16ed55891ce142.png]: https://img-blog.csdnimg.cn/443a97bda5174f539c16ed55891ce142.png
[dd32f945378741b7983e483898ebdc44.png]: https://img-blog.csdnimg.cn/dd32f945378741b7983e483898ebdc44.png
[8c7ecc187f7842549c500b03bd7d85ed.png]: https://img-blog.csdnimg.cn/8c7ecc187f7842549c500b03bd7d85ed.png
[5b9f921e912e4e30ae83bd87cf92a5fc.png]: https://img-blog.csdnimg.cn/5b9f921e912e4e30ae83bd87cf92a5fc.png
[e1826cdd7a8c4c16a7c221621d4744e7.png]: https://img-blog.csdnimg.cn/e1826cdd7a8c4c16a7c221621d4744e7.png
[c30085b0137b4bb985bc42aed24aec79.png]: https://img-blog.csdnimg.cn/c30085b0137b4bb985bc42aed24aec79.png
[382de2c47e1e452cbce25842a21ac406.png]: https://img-blog.csdnimg.cn/382de2c47e1e452cbce25842a21ac406.png
[qsort]: https://legacy.cplusplus.com/reference/cstdlib/qsort/?kw=qsort
[e67d2a86bee34d6e8ab246626c1fe478.png]: https://img-blog.csdnimg.cn/e67d2a86bee34d6e8ab246626c1fe478.png
[d1bfbd3a491f4d7d8a5a0759e3ffe5cb.png]: https://img-blog.csdnimg.cn/d1bfbd3a491f4d7d8a5a0759e3ffe5cb.png
[55ffd981c2184a849e5db92892fedb06.png]: https://img-blog.csdnimg.cn/55ffd981c2184a849e5db92892fedb06.png
[5b1735de91e24d9486d04d041c50d519.png]: https://img-blog.csdnimg.cn/5b1735de91e24d9486d04d041c50d519.png
[ca9c6d9ac7a64a61977d427ed7bd4751.png]: https://img-blog.csdnimg.cn/ca9c6d9ac7a64a61977d427ed7bd4751.png
[fe0e8b19cd0b418b82f82947b1a8a1ac.png]: https://img-blog.csdnimg.cn/fe0e8b19cd0b418b82f82947b1a8a1ac.png
[f8850fcf13f54d49b4b4c90e59d2df1c.png]: https://img-blog.csdnimg.cn/f8850fcf13f54d49b4b4c90e59d2df1c.png