（C语言进阶）指针进阶（中）

最新推荐文章于 2024-05-11 15:07:54 发布

南橘Q

最新推荐文章于 2024-05-11 15:07:54 发布

阅读量46

点赞数 1

文章标签： c语言开发语言

本文链接：https://blog.csdn.net/qhnaijuzi/article/details/130532040

版权

本章主要内容：

7. 指向函数指针数组的指针
8. 回调函数

———————————————————————————————————————————

回顾我们之前所学的：

int my_strlen(const char* str)
{
	return 0;
}

int main()
{
	//指针数组
	char* arr[10];
	//数组指针
	int arr2[5] = { 0 };
	int(*p)[5] = &arr2;//p是一个指向数组的指针变量
	//函数指针
	int (*pf)(const char*) = my_strlen;//pf是一个指向函数的函数指针变量
	//调用：(*pf)("abcdef")
	//my_strlen("abcdef")
	//pf("abcdef")
	
	//函数指针数组 - 存放函数指针的数组
	int (*pfArr[10])(const char*);

	return 0;
}

指针数组

数组指针

函数指针

函数指针数组

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

指向函数指针数组的指针是一个指针

指针指向一个数组，数组的元素都是 函数指针

如何定义？

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int main()
{
	//函数指针pffun
	int(*pffun)(int, int) = Add;
	//函数指针数组
	int (*pfArr[4])(int, int) = { Add,Sub };
	//函数指针数组的指针
	int (*(*ppfArr)[4])(int, int) = &pfArr;//ppfArr是一个指向函数指针数组的指针变量
	//(*ppfArr)是一个指针指向一个数组数组里有四个元素，类型是int (*)(int, int)
	return 0;
}

8. 回调函数

概念：

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

8.1引入

为了更好理解我们通过计算器实现的例子来进行理解：

如下是我们实现计算器冗余的一种写法。

//计算器的实现的一种写法
//因为避免在不需要输入的时候出现"请输入两个操作数"的操作
//因此才出现了这种在满足我们执行函数时，使用多个print和scanf的冗余写法
void menu()
{
	printf("*************************\n");
	printf("****** 1:Add 2:Sub ******\n");
	printf("****** 3:Mul 4:Div ******\n");
	printf("*************************\n");
}
 
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;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		menu();
		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;
}

因此为了减少冗余，并且只我们使用函数的时候才让用户输入两个操作数，优化有了如下写法：

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");
}
void Calc(int(*pf)(int, int))
{
	int x = 0;
	int y = 0;
	printf("请输入两个操作数:>");
	scanf("%d %d", &x, &y);
	int ret = (*pf)(x, y);//调用函数指针指向的函数
	//int ret = pf(x,y);
	printf("%d\n", ret);
}

int main()
{
	int input = 0;
	
	do
	{
		menu();
		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;
}
这种写法运用了回调函数。

当输入1时，程序选择case1进入，然后进入Calc函数。把Add函数地址传给Calc的函数指针，之后指针Calc拿到的就是int Add（int x，int y）的函数地址了，因此就指向这个函数。之后就是输入两个操作数，之后通过pf调用我们指向的函数并把x，y两个值传进去（ret=pf(x,y)）并输出和的结果。选择其他函数过程也是同理。

因此从上面来看，没有对函数直接调用，而是通过传入地址作为参数传给另一个函数，在另一个函数中调用（响应）用指针调用的函数，该函数为回调函数。因此这里Add是回调函数。(通过函数里的函数指针调用函数的响应)

8.2qsort的运用

我们曾学过冒泡排序：

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 + 1] < arr[j])
			{
				int temp = arr[j+1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

冒泡排序只能排一种类型的数据，不能排放任意类型的数据。

为了解决这个问题，我们推荐使用qsort函数。

使用qsort的好处是：

1.qsort是一个库函数，是用来排序的库函数（现成的，直接调用）

2.可以排序任意类型的数据

下面是qsort函数组成：
void qsort(void* base, //指向了待排序数组的第一个元素
	       size_t num, //待排序的元素个数
	       size_t size, //每个元素的大小，单位是字节
	       int (*compar)(const void*, const void*)//指向一个函数，这个函数可以比较2个元素的大小
           );
1.qsort排序需要提供排序的方法，即提供一个函数。

2.同时需要注意：void*是无具体类型的指针，所以它可以接收任意类型的地址
例3如：
int a = 10;
void* p =&a;
*p;
p++;
*(int*)p;
void* p =&a //void*是无具体类型的指针，可以接收
*p； //不可以，void*的指针不可以使用解引用操作符，因为不知道访问多少个字节
p++ //同理也是不可以的，不知道可跨越的字节数
*(int*)p //如果想使用可以对其进行强制转换

3.compar

注意其返回值，返回值的不同也影响了排序的方向。（下面的冒泡就有所体现）

qsort的排序方式默认是升序。

同时注意qsort是可以排序任意类型的数据，因此需要排序需要注意变通

1.比较2个数的大小时，可以直接返回强制转换的类型的解引用指针两者的差值，例如：return *(int*)p1 - *(int*)p2;

2.比较2个字符串的大小时，不能直接返回值，需要用strcmp来比较两个字符串的大小，将strcmp的值进行返回

3.比较两个结构体的数据（这里先挖个坑，未具体展开）

具体实现：

1.使用回调函数，模拟实现qsort（采用冒泡的方式）(注意这里void*p的使用)

//qsort函数的使用者提供这个函数
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;//升序
	//return *(int*)p2 - *(int*)p1;//降序
}
 
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
 
test1()
{
	int arr[] = {3,5,8,2,4,1,6,9,4,7,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
    //使用qsort来排序整型数组，这里就要提供一个比较函数，这个比较函数能够比较2个整数的大小
	//qsort函数默认排成升序，可以互换指针完成降序
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}
 
int main()
{
	test1();
	return 0;
}

运行结果：

（升序结果）

（降序结果）

2.qsort模拟实现排序结构体

（根据年龄排序）

#include <stdio.h>
#include<stdlib.h>
 
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;
}
 
test2()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",23}, {"wangwu",30} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
 
int main()
{
	test2();
	return 0;
}

通过监视查看排序结果为：

按照名字排序

#include <stdio.h>
#include<string.h>
struct Stu
{
	char name[20];
	int age;
};

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

test3()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}

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

通过监视查看排序结果为：

8.3qsort的模拟实现

qsort底层是快速排序,但是我们还没有接触过快速排序的思想。

因此我们使用冒泡排序的思想来实现一个类似于qsort这个功能的冒泡排序函数bubble_sort()

代码实现：

#include <stdio.h>
#include<string.h>
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}
void Swap(char* buf1, char* buf2, size_t width)
{
	size_t i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}


//假设排序为升序
//希望这个bubble_sort函数可以排序任意类型的数据
void bubble_sort(void*base,size_t num,size_t width,int (*cmp)(const void* p1,const void* p2))
{
	//确定趟数
	size_t i = 0;//注意这里的类型
	for (i = 0; i < num - 1; i++)
	{
		size_t j = 0;//注意这里的类型
		for (j = 0; j < num - 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);
			}
		}
	}
}

test3()
{
	int arr[] = { 3,1,2,4,9,8,6,5,7 };
	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;
}

代码分析过程：

冒泡排序模拟实现排序结构体

按年龄进行排序

#include <stdio.h>
#include<stdlib.h>

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

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

//希望这个bubble_sort可以排序任意类型的数据
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//两个相邻元素的比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

test4()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}

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

通过监视查看排序结果为：

按照名字排序

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

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

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


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

//希望这个bubble_sort可以排序任意类型的数据
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//两个相邻元素的比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

test4()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}

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

通过监视查看排序结果为：

模拟实现冒泡排序优化，可以这样：

void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		int flag = 1;
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//两个相邻元素的比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				flag = 0;
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

（本章完，但还有一个小坑）