深入了解指针(4)

1. 回调函数是什么？

回调函数就是⼀个通过函数指针调⽤的函数。

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

以下是上一小节计算器的实现的代码以及对代码修改为回调函数的对比，红色框就上二者的不同之处：

因为红⾊框中的代码，只有调⽤函数的逻辑是有差异的，我们可以把调⽤的函数的地址以参数的形式传递过去，使⽤函数指针接收，函数指针指向什么函数就调⽤什么函数，这⾥其实使⽤的就是回调函数的功能。 

2. qsort使⽤举例

2.1 使⽤qsort函数排序整型数据

//写一个冒泡排序的函数，对一组整型数据进行排序，排序为升序
#include<stdio.h>
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++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

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

int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//排为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	print_arr(arr, sz);
	return 0;
}

以上的比较大小的方法只适用于整型，那如果我们要比较字符串呢？

我们可以改造这个函数，让它能够排序任意类型的数据

那哪些地方需要改造呢？

两个整型元素可以直接使用>比较，但是两个字符串、两个结构体元素是不能使用>来比较的！

这时我们可以借助strcmp，strcmp是按照对应的字符串中的字符的ASCII码值进行比较的

是一一对应比较的

a b c d e

|   |  |  |   |

a b p

abp>abcde

因为a=a,b=b,c<p 

qsort是用来排序的库函数，直接可以用来排序数据，底层使用的是快速排序的方式

qsort函数可以排序任意类型的数据

void qsort(void* base,size_t num,size_t size,int (*compar)(const void*,const void*) 

//void qsort(void* base, //指针，指向的是待排序的数组的第一个元素

// size_t num, //是base指向的待排序数组的元素个数

// size_t size, //base指向的待排序数组的元素的大小

// int (*compar)(const void*, const void*)//函数指针 - 指向的就是两个元素的比较函数

// );

 

//void* 类型的指针是无具体类型的指针，这种类型的指针不能直接解引用，也不能进行+-整数的运算

//qsort 函数有实现者 -

//qsort 函数的使用者 - 明确的知道要排序的是什么数据，这些数据应该如何比较，所以提供两个元素的比较函数

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

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

//> --->  >0
//< --->  <0
//== ---> ==0
//
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}


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

int main()
{
    test1();
}

2.2 使⽤qsort排序结构数据

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;
}
// strcmp - 是库函数，是专⻔⽤来⽐较两个字符串的⼤⼩的
// 假设按照名字来⽐较
int cmp_stu_by_name(const void *e1, const void *e2)
{
	return strcmp(((struct Stu *)e1)->name, ((struct Stu *)e2)->name);
}

//打印年龄
void printage(struct Stu s[],int len)
{
	for(int i=0;i<len;i++)
	{
		printf("%d ",s[i].age);
	}
	printf("\n");
}

//打印名字
void printname(struct Stu s[],int len)
{
	for(int i=0;i<len;i++)
	{
		printf("%s ",s[i].name);
	}
	printf("\n");
}


// 按照年龄来排序
void test2()
{
	struct Stu s[] = {{"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15}};
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
    printage(s,sz);
}
// 按照名字来排序
void test3()
{
	struct Stu s[] = {{"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15}};
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	printname(s,sz);
}



int main()
{
	test2();
	test3();
	return 0;
}

3. qsort函数的模拟实现

使⽤回调函数，模拟实现qsort（采⽤冒泡的⽅式）。

注意：这⾥第⼀次使⽤ void* 的指针，讲解 void* 的作⽤。

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

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


void Swap(char* buf1,char* buf2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void*p1, const void*p2))
{
	//趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//一趟内部的两两比较
		int j = 0;
		for (j = 0; j < sz-1-i; j++)
		{
			//比较arr[j] 和 arr[j + 1]
			if (cmp((char*)base+j*width, (char*)base+(j+1)*width)>0)//改变
			{
				//交换两个元素
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

//测试的是bubble_sort排序整型数据
void test3()
{
	int arr[] = { 3,1,7,8,5,2,4,9,0,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}



int main()
{


	test3();

	return 0;
}

​​​​​​​