指针的学习4

目录

回调函数

qsort使用样例

使用qsort函数排序整形数据

使用qsort函数排序结构体

---

回调函数

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

qsort使用样例

使用qsort函数排序整形数据

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

冒泡排序：

#include <stdio.h>
void bubble_sort(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;
			}
		}
	}
}
void print_arr(int arr[], int sz)
{
	for (int i = 0; i < sz; i++)//
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	//写一个冒泡排序的函数，对一组整形数据进行排序，排序为升序
	int arr[] = { 9,8,7,6,5,4,3,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);
	print_arr(arr, sz);
	return 0;
}

冒泡排序只能用来实现对一种类型数据的排序

qsort可以实现对任意类型的数据进行排序

void qsort(void* base,//指向的是待排序的数组的第一个元素
    size_t num,//base指向的数组里面的元素个数
    size_t size,//base指向的数组中元素的大小
    int (*compar)(const void*, const void*));//函数指针
//4个参数

那么，要想使冒泡排序能够排序任意类型数据，应该怎样改造呢？

两个整型元素可以使用>进行比较，但是两个字符串、两个结构体元素不能够用>进行比较

两个字符串用strcmp进行比较

void bubble_sort(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;
			}
		}
	}
}

中间无非是两个元素进行比较，可以封装成函数，然后把函数的地址传给排序函数

而qsort函数就是这样进行排序的：

void qsort(void* base,//指向的是待排序的数组的第一个元素
    size_t num,//base指向的数组里面的元素个数
    size_t size,//base指向的数组中元素的大小
    int (*compar)(const void*, const void*));//函数指针
//4个参数

这里的函数指针指向的就是两个元素的比较函数

//qsort函数有实现者
//qsort函数的使用者-明确的知道要排序的是什么数据，这些数据应该如何比较，所以提供两个元素的比较函数
int cmp_int(const void* p1, const void* p2)//存放待比较两个元素的地址
{
	//升序
	//void*类型的指针是无具体类型的指针，这种类型的指针不能直接解引用，也不能进行+-整数的运算
	return (*(int*)p1 - *(int*)p2);//同下
	//return (*(int*)p2 - *(int*)p1);降序
	/*if (*(int*)p1 > *(int*)p2)
		return 1;
	else if (*(int*)p1 == *(int*)p2)
		return 0;
	else
		return -1;*/
}
void print_arr(int arr[], int sz)
{
	for (int i = 0; i < sz; i++)//
	{
		printf("%d ", arr[i]);
	}
}
void test()
{

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

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

使用qsort函数排序结构体

.和->都是结构体成员访问操作符

结构体变量.成员名

结构体指针->成员名

struct Stu
{
	char name[20];
	int age;
};
int main()
{
	struct Stu s = { "zhangsan",18 };
	printf("%s %d\n", s.name, s.age);
	return 0;
}

再看下面这段代码：

struct Stu
{
	char name[20];
	int age;
};
void print(struct Stu* ps)
{
	printf("%s %d\n", (*ps).name, (*ps).age);
}
int main()
{
	struct Stu s = { "zhangsan",18 };
	//printf("%s %d\n", s.name, s.age);
	print(&s);
	return 0;
}

很明显麻烦了！此时，可以这样写代码：

void print(struct Stu* ps)
{
	//printf("%s %d\n", (*ps).name, (*ps).age);
	printf("%s %d\n", ps->name, ps->age);//结构体指针的用法
}

---

struct Stu
{
	char name[20];
	int age;
}s,s1;//s,s1是结构体变量，是一样的
typedef struct Stu
{
	char name[20];
	int age;
}stu;//stu是类型名

struct Stu
{
	char name[20];
	int age;

};
//这里的结构体怎么比较大小？
//1.按照名字比较-字符串比较strcmp
//2.按照年龄比较-整型比较
//按照需求比较
int cmp_stu_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);//比较两个字符串-按照对应字符串中字符的ASCII码值比较
}
void test()//对结构体进行排序
{
	struct Stu arr[3] = { {"zhangsan",20},{"lisi",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr,sz,sizeof(arr[0]),cmp_stu_by_name);

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

我们模仿qsort来实现一个冒泡排序的函数，这个函数可以对任意类型数据进行排序

int cmp_int(const void* p1, const void* p2)//存放待比较两个元素的地址
{
	//升序
	//void*类型的指针是无具体类型的指针，这种类型的指针不能直接解引用，也不能进行+-整数的运算
	return (*(int*)p1 - *(int*)p2);
}

void Swap(char* buf1,char* buf2,size_t width)//交换
{
	for (int 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))
{
	for (int i = 0; i < sz - 1; i++)
	{
		//趟数
		for (int j = 0; j < sz - i - 1; 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);
			}
		}
	}
}
void print_arr(int arr[], int sz)
{
	for (int i = 0; i < sz; i++)//
	{
		printf("%d ", arr[i]);
	}
}
void test()
{
	int arr[] = { 2,1,4,3,5,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz,sizeof(arr[0]),cmp_int);//排序整型
	//bubble_sort(arr2, );//排序结构体
	print_arr(arr, sz);
}

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

注意：这个代码是迄今为止最复杂的一个代码！！！