C语言指针进阶-全面分析C指针重难点逐一突破(终篇)

C语言指针进阶-全面分析C指针重难点逐一突破(终篇)

大家好，我是枫晨~，指针终于要在今天落下帷幕，分别有前篇，中篇，以及今天的终篇，这三篇文章是环环相扣的，所以说跳着看的话可能会吃力。
好了，让我们学习最好一点知识，详细深入了解回调函数以及qsort函数的使用

回调函数

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

用一段代码去了解这段话：

void test()
{
    printf("我是回调函数\n")
}

void my_print(void(*p)())
{
    p();
}

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

总结概括：将一个函数（test）的地址传入另外一个函数（my_print）中，在（my_print）接收这个地址，并且函数中利用test的地址去调用test函数，此时test函数被称为回调函数。

解决了回调函数的概念，我们就在实战中应用一下回调函数把！

应用1：简化计算器

指针中篇中，我们在文末写了一个简易计算器，但是大家是否记得第一个计算器版本因为使用的是switch，结果整个代码**“又臭又长“**，当我们遇到回调函数的时候，它拯救了这个版本的计算器~

第一版：

//定义加减乘除功能的函数
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 input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
        //选择计算方式
		switch (input)
		{
		case 0:
			printf("退出程序\n");
			break;
		case 1:
			ret = Add(x, y);
			printf("输入两个数:>");
			scanf("%d %d", &x, &y);
			printf("%d\n", ret);
			break;
		case 2:
			ret = Sub(x, y);
			printf("输入两个数:>");
			scanf("%d %d", &x, &y);
			printf("%d\n", ret);
			break;
		case 3:
			ret = Mul(x, y);
			printf("输入两个数:>");
			scanf("%d %d", &x, &y);
			printf("%d\n", ret);
			break;
		case 4:
			ret = Div(x, y);
			printf("输入两个数:>");
			scanf("%d %d", &x, &y);
			printf("%d\n", ret);
			break;
		default:
			printf("输入错误，重新输入:>");
			break;
		}
	} while (input);
	return 0;
}

利用回调函数简化

//将冗余重复部分用函数封装

void calc(int(*p)(int,int))//p是函数指针，传过来哪个函数地址就用哪种类型计算
{
    int x = 0;
	int y = 0;
	int ret = 0;
    printf("输入两个数:>");
	scanf("%d %d", &x, &y);
    ret = p(x,y);
	printf("%d\n", ret);
}

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 input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
        //选择计算方式
		switch (input)
		{
		case 0:
			printf("退出程序\n");
			break;
		case 1:
                calc(Add);
			break;
		case 2:
                calc(Sub);
			break;
		case 3:
                calc(Mul);
			break;
		case 4:
                calc(Div);
			break;
		default:
			printf("输入错误，重新输入:>");
			break;
		}
	} while (input);
	return 0;
}

使用回调函数以后，整个计算器虽然没有使用函数指针数组那样简洁，但是也比第一种“又臭又长”的代码好了特别多吧~

应用2：qsort库函数的使用

qsort：基于快速排序算法实现的一个排序函数；头文件:<stdlib.h>
优点：可以排序任意类型的数据

在学习qsort函数之前，先了解一下冒泡排序，看看他们两个排序有怎么样的区别

何为冒泡排序？

用于对整形数组进行排序
冒泡排序主要分为两大部分
①确定需要排序的趟数
②对每一趟的排序方法和细节进行设计

缺点：只能排序整数数组类型数据，通用性不强

//冒泡排序
void bubble_sort(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++)//-i原因：每排序一趟，需要排序的数组就少一组
        {
            if (arr[j] > arr[j + 1])//按照升序方式排序
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main()
{
    int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
    int sz = sizeof(arr) / sizeof(arr[10]);//计算数组里面有几个元素
   bubble_sort(arr, sz);
    //打印出排序后的数组
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

图解分析：

qsort函数介绍

qsort要求使用者自定义一个比较函数，通过用户指定任意类型以任意方式排序，可以实现对任何类型的数据排序。

运用qsort进行排序

//打印数组排序后的结果
void my_print(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}

int main()
{
    int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
     //cmp_int：定义按照通过比较每个整形元素大小的方式对e1，e2进行比较
    qsort(arr, sz, sizeof(arr[0]), cmp_int);
    //打印排序后的数组
    my_print(arr, sz);
    return 0;
}

//定义比较方式的函数---版本1
int cmp_int(const void* e1, const void* e2)
{
    //void*存储的地址不能直接进行解引用
    //需要将指针进行强制类型转换为整形才可以解引用
    if(*(int*)e1>*(int*)e2)//将数组arr排序为升序
    {
        return 1;// e1 > e2返回一个大于0的数
    }
    else if(*(int*)e1==*(int*)e2)
    {
        return 0;//e1 和 e2相等，返回0；
    }
    else
    {
        return -1;//e1 < e2返回小于0的数
    }
}

 //定义比较方式的函数---版本2
int cmp_int(const void* e1, const void* e2)
{
   //版本2--简易版
   // 若e1 大于 e2，相减大于0，e1 等于 e2，相减等于0，e1 小于 e2 相减小于0
   return (*(int*)e1 - *(int*)e2);
}

void*指针类型

void * 指针可以存放任何类型的地址，堪称是指针类型界的垃圾桶，别人不要的东西它可以要，别人可以要的东西它也可以要

int a = 10;
float *pf = &a;//这是错误的写法，编译器会出现警告
//void*
void * pv = &a;//编译器不会有任何警告

①使用void * 指针类型时候需要注意，使用void * 存储的变量是不能直接解引用的，如const void * e1，*e1是错误的写法，想解引用void * 中存储的内容，必须先使用强制类型转换 *（int * ) e1

②void * 指针类型变量不能直接+1，如 e1+1，是错误的，void * 并不像int * 一样有明确的访问数据范围，如 int * pa = &a; pa+1代表访问了a地址往后4个位置的地址空间；

为什么说qsort函数可以排序任意一种类型的数组？现在写的不是和冒泡排序一样排序的是整形数组么，没有什么区别啊。
那接下来，就用qsort排序结构体数组

struct stu
{
  char name[20];
  int age;
};

void my_print(struct stu *arr, int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++ )
    {
        printf("%s\n", (arr[i]).name);
    }
}

int main()
{
    struct stu arr[3] = { {"zs",25},{"ls",20},{"ww",18} };
    int sz = sizeof(arr) / sizeof(arr[0]);
    //cmp_by_name：定义一个通过结构体名字的顺序来排序的函数
    my_print(arr, sz);
    qsort(arr, sz, sizeof(arr[0]), cmp_by_name);
    printf("\n");
    my_print(arr, sz);

    return 0;
}

int cmp_by_name(const void* e1, const void* e2)
{
    //比较字符串，必须使用strcmp函数比较
    return strcmp(((struct stu*)e1)->name,((struct stu*)e2)->name);
}

qsort函数模拟—深入了解qsort函数

模拟实现qsort（采用冒泡的方式）

前面的文章有提过如何尽量的模拟一个函数，尽量做到和这个模拟函数的参数细节相同

通过刚刚的分析，我们知道qsort函数主要有以下几大部分组成：
base，num，width，cmp函数，e1和e2
并且qsort函数默认是升序排序，如需修改，将e1，e2位置调换即可

①：为什么设计base参数的时候使用void * 的指针类型？
原因在于设计者也无法预测使用者会用qsort函数排序什么类型的数据，而void * 的指针类型是万能的，可以存储任何数据类型的地址，只需要在使用的时候按照待排序的数据强制类型即可

②为什么要知道待排序数据元素的个数（num）？
设计者也不知道使用者会用它排序多少个元素的数据

③为什么需要待排序数组中一个元素的占内容的大小？
方便读取数组中的数据，如果不知道大小，很可能访问数据的时候会遗漏一些数据
如int * 类型的数据，加一每次跳过4个bit的空间，而char * 类型数据加一只跳过1个bit的空间。

④为什么要设计一个函数指针cmp？
回顾我们刚刚写的冒泡排序，他只能针对整形数据内容进行升序排序，不能像qsort函数那样可以给结构体中的字符进行排序，区别就在于刚刚的冒泡排序的排序方法是固定死的，而qsort函数的排序方法是自由的，由使用者自己依据排序的数据类型定义cmp函数内的排序方法。

⑤：为什么e1和e2类型是const void*类型
和前面一样，设计者也无法预测使用者将会用qsort函数排序怎么样的数据类型；

将qsort函数解析完以后，我们便可以开始着手模拟

//qsort函数模拟（基于冒泡排序）
void bubble_sort(void* base, int num, int width, int(*cmp)(const void* e1, const void* e2))
{
    //冒泡排序大题思路不需要改变，只需要对排序方式进行即可
    //确定需要排序的趟数
    int i = 0;
    for (i = 0; i < num - 1; i++)
    {
        //对每趟排序的方法和细节进行设计
        int j = 0;
        for (j = 0; j < num - 1 - i; j++)//-i原因：每排序一趟，需要排序的数组就少一组
        {
            if (cmp((char*)base + j * width, (char*)base + (j + 1) * width)>0)
            {
                swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}
//swap函数：交换函数，如果e1大于e2，则swap函数执行
void swap（char* buf1,char* buf2,int width)
{
    char tmp = *buf1;
    *buf1 = *buf2;
    *buf2 = tmp;
    buf1++;
    buf2++;
}

这样qsort内部工作流程就完成了,接下来就是对代码的具体解析：

那如何实现交换呢？

这里单独独立了一个swap函数，用于对需交换的数据进行交换，同样也是使用的char类型的指针作为参数，目的就是为了保证模拟的qsort函数的适用性，利用width(每个元素的大小)，元素多大就依次交换几次。

用一张图来看看这个代码到底是怎么工作的来结束我们这篇文章的学习

---

好啦,C语言中的指针已经更新完啦，后续如果有遗漏知识点我会补充进来，接下来就是对指针进阶所有知识的一个习题练习，这份习题包含各个大厂曾经的面试笔试题，期待一下吧~

惯例：一天不要沉浸在焦虑中，要保持微笑的学习~