深入理解指针(4)

在学习之前的深入理解指针(3)中我们对字符指针以及函数指针，函数指针数组等知识进行了深入的理解，并且使用这些知识了解了二维数组传参的本质；利用函数指针数组实现转移表，现在将继续学习指针更多的知识，一起加油吧！！！ 

1.回调函数

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

 在之前深入理解指针(3)中在计算器的一般实现代码中，一开始我们使用的是do...while实现各种计算，其实这个代码除了主函数内使用多个case语句，代码还存在冗余，重复的问题

 可以看出在4个case语句中只有调用的函数不同，这时如果将这些代码封装在一个函数Calc里，再调用这个函数的时候传给计算函数的函数名，例如Add

这样就会使得Calc可通过指针调用函数，这就是使用了回调函数 

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

void Calc(int* (pf)(int, int))
{
	int x = 0;
	int y = 0;
	printf("输入操作数：");
	scanf("%d %d", &x, &y);
	int ret = pf(x, y);
	printf("ret = %d\n", ret);
}


int main()
{
	int x = 0;
	int y = 0;
	int input = 1;
	int ret = 0;
	do
	{
		printf("*************************\n");
		printf("  1:Add           2:Sub  \n");
		printf("  3:Mul           4:Div  \n");
		printf("  0:exit                 \n");
		printf("*************************\n");
		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("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

2.qsort函数

1.qsort函数的作用

在之前深入深入理解指针(2)中学习了通过冒泡排序的方法实现整形数组的排序，当如果再要排序字符数组；结构体数组之前的代码就无法再实行排序了
所以这时就需要用到qsort这个库函数来实现不同类型数据的排序了
qsort函数的作用是可以对任意类型的数组元素进行排序

2. 如何使用qsort函数

再来了解要使用qsort函数时需要的参数

c++官网内qsort具体讲解
 

通过c++官网内对qsort的使用说明可以看出使用qsort时需要3个参数，传的第一个参数是首元素的地址（指针），第二个参数是数组内元素的个数，第三个是数组内各个元素的大小（以字节为单位），传的最后的参数是用于比较数组内两个元素的函数

3.qsort使用举例

我们知道使用qsort时，需要设计一个函数用于数组内元素的比较，这里再在c++官网中查看使用qsort时对进行比较元素的函数有要求

由以上可以看出当p1指向的元素大于p2指向的元素返回大于0的数，p1指向的元素小于p2指向的元素返回小于0的数，p1指向的元素等于p2指向的元素返回0

 在qsort形参部分内的函数指针的参数都是const void*，所以我们设计的函数参数也要和该函数指针参数类型一致，也为const void*（const只需在*左边即可，在void两边都是可以的）

1.排序整形数组 

int main()
{
	int arr[] = { 5,9,8,6,7,4,1,3,2 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr,sz,sizeof(arr[0]),cmp_int);
	Print(arr, sz);
		
	return 0;
}

了解完以上要求就可以来设计cmp_int函数了

int cmp_int(void const* p1, void const* p2)
{
	if (*(int*)p1 > *(int*)p2)
	{
		return 1;
	}
	else if (*(int*)p1 < *(int*)p2)
	{
		return -1;
	}
	else
	{
		return 0;
	}

}

由于以上代码一开始p1与p2两个指针变量的类型都为void*，在深入理解指针(1)中了解过void*类型的指针变量是不能进行解引用的，所以这时就需要用到强制类型转换
先将指针变量p1，p2转换为int*类型再进行解引用找到相应的数组元素

因为该函数内当p1指向的元素大于p2指向的元素返回大于0的数即可，p1指向的元素小于p2指向的元素返回小于0的数即可，p1指向的元素等于p2指向的元素返回0即可

以上函数还可以简化为：

int cmp_int(void const* p1, void const* p2)
{
	return *(int*)p1 - *(int*)p2;
}

完整代码：

#include<stdio.h>

int cmp_int(void const* p1, void const* p2)
{
	return *(int*)p1 - *(int*)p2;
}

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

//使用qsort排序整形数组
int main()
{
	int arr[] = { 5,9,8,6,7,4,1,3,2 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr,sz,sizeof(arr[0]),cmp_int);
	Print(arr, sz);
		
	return 0;
}

 运行代码测试能否实现排序功能

2.排序结构体数据

struct Stu//结构体类型
{
	char name[30];
	int age;
};

int main()
{
	struct Stu arr[] = { {"ZhangSan",18},{"LiSi",20},{"WangWu",19} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz,sizeof(arr[0]), cmp_stu_name);
    qsort(arr, sz, sizeof(arr[0]), cmp_stu_age);
	
	return 0;
}

 在以上代码中创建了三个结构体变量并存放在数组arr中，现在要将arr内的变量按照name的长度来排序数组内的变量，现在需要创建一个函数cmp_stu_name来比较各结构体变量内name的长度，创建一个函数cmp_stu_age来比较各结构体变量内age的大小

在之前结构体成员操作符中学到了.操作符，其实结构体成员操作符中还有->操作符，使用方法是结构体指针->成员变量

#include<stdio.h>
struct stu
{
	int age;
	char name[10];
}s1 = { 19,"lisi" };

int main()
{
	struct stu* p = &s1;
	printf("%s %d", p->name, p->age);

	return 0;
}

 例如以上代码就可以通过指针的方式找到结构体变量s1内的各个成员

int cmp_stu_name(void const* p1, void const* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}

int cmp_stu_age(void const* p1, void const* p2)
{
	return ((struct Stu*)p1)->age- ((struct Stu*)p2)->age;
}

由于p1和p2类型都是void*，所以要强制类型转换为struct  Stu*，同时将转换后的用（）扩起来
再使用->找到结构体变量内的成员

在此字符串的比较我们还要了解一个库函数strcmp

strcmp是用来比较两各字符串，当第一个字符串大于第二个字符串时返回大于0的数，当第一个字符串小于第二个字符串时返回小于0的数，当第一个字符串等于第二个字符串时返回0

我们发现strcmp返回值与我们期望cmp_stu_name的返回值一模一样 所以就可直接返回strcmp的返回值

完整代码：

#include<stdio.h>
#include<string.h>

struct Stu
{
	char name[30];
	int age;
};


int cmp_stu_name(void const* p1, void const* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
int cmp_stu_age(void const* p1, void const* p2)
{
	return ((struct Stu*)p1)->age- ((struct Stu*)p2)->age;
}


int main()
{
	struct Stu arr[] = { {"ZhangSan",18},{"LiSi",20},{"WangWu",19} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz,sizeof(arr[0]), cmp_stu_name);
    qsort(arr, sz, sizeof(arr[0]), cmp_stu_age);
	
	return 0;
}

 调试程序测试代码运行后是否符合预期
在按名字排序后

在按年龄排序后

4.qsort函数的模拟实现 

在之前设计的冒泡排序只能排序整形类型的数据，那应该如何修改才能让该函数排序任意类型的数据呢？

无论是什么类型的数据排序在以上代码中趟数与每趟内部比较的次数代码都是可行的，但这里面的比较元素的代码就需重新设计了，但要比较两元素时候就调用我们自己设计的比较函数cmp，若返回值大于0就进入if语句内

在函数参数也有需修改的地方，因为我们要实现的是任意类型数组的排序，这时就无法确定实参传递过来的是什么类型的数据，所以形参就用void*来接收数组首元素的指针

同时由于不知道是什么类型的元素，所以还需要传一个数组内每个元素的大小（也就是每个元素的宽度）给bubble_sort

 bubble_sort函数参数

void bubble_sort(void* base, size_t sz,size_t width,int(*cmp)(const void* ,const void* ))

在设计判断数组内两元素大小的代码时，首先要知道的是通过调用比较函数来实现的，并且每趟内部俩俩元素比较就要先将指针bse强制类型转换为char*
（注：这强转为char*是为了使所有类型的元素都通用）

并且还不知道指针+1的步长就需要再给j乘上width

void bubble_sort(void* base, size_t sz,size_t width,int(*cmp)(const void* ,const void* ))
{
	for (int i = 0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (cmp((char*)base+j*width, (char*)base+(j+1)*width)>0)
			{
				;
			}
		}
	}

最近若进入if语句时候，就说明要交换两个元素的位置，这时就需再设计一个函数来交换两个元素的位置

因为不知是对什么类型的数据进行交换，这时我们就需要让两个元素的每个字节都进行交换，这也是之前将base指针强转为char*的原因（char类型指针+1步长为1）

void swap(char* pf1, char* pf2,int width)//pf来接收第一个元素的指针，pf2用来接收第二个元素的指针
{
	char tmp = 0;
	int i = 0;
	for (i = 0; i < width; i++)//让两元素每个字节都交换
	{
		tmp = *pf1;
		*pf1 = *pf2;
		*pf2 = tmp;

		pf1++;
		pf2++;
	}
}

自此就将bubble_sort函数的全部功能都设计完成了，这时我们对一个整形数组进行排序，以下是完整代码：

#include<stdio.h>

void swap(char* pf1, char* pf2,int width)//pf来接收第一个元素的指针，pf2用来接收第二个元素的指针
{
	char tmp = 0;
	int i = 0;
	for (i = 0; i < width; i++)
	{
		tmp = *pf1;
		*pf1 = *pf2;
		*pf2 = tmp;

		pf1++;
		pf2++;
	}
}

void bubble_sort(void* base, size_t sz,size_t width,int(*cmp)(const void* ,const void* ))
{
	for (int i = 0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (cmp((char*)base+j*width, (char*)base+(j+1)*width)>0)
			{
				swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
			}
		}
	}
}

int cmp_int(const void*pf1, const void*pf2)
{
	return *(int*)pf1 - *(int*)pf2;
}


int main()
{
	int arr[] = { 57,4,9,2,3,66,72 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

运行程序检验程序是否能模拟实现qsort排序的功能

通过以上结果可以得出代码设计没有问题

以上就深入理解指针(4)的全部内容，希望看完以上内容你能有所收获，接下来还会继续更新指针的其他内容，未完待续....