指针进阶(2)

文章目录

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

6. 函数指针数组

之前我们已经学习过指针数组,比如整型指针数组等,因此我们可以以此进行类比:

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

int main()
{
	//int (*pf1)(int, int) = Add;
	//int (*pf2)(int, int) = Sub;
	//int (*pf3)(int, int) = Mul;
	//int (*pf4)(int, int) = Div;
	//函数指针数组
	int (*pfArr[4])(int, int) = { Add, Sub, Mul, Div };//pfArr先和[]结合,说明pfArr是数组,数组的内容int (*)(int, int)类型的函数指针。

	return 0;
}

函数指针数组的用途:转移表
我们可以举一个计算器的例子:

我们先不用函数指针数组:

#include 

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

我们可以发现以上代码的switch语句中用许多代码是重复的

解决方法:使用函数指针数组

#include 

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;
	//函数指针数组的使用 - 转移表
	int (*pfArr[5])(int, int) = { NULL, Add, Sub, Mul, Div };
	//                            0     1    2    3    4
	
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);

		if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数:");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("ret = %d\n", ret);
		}
		else if (0 == input)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("选择错误,重新选择\n");
		}

	} while (input);

	return 0;
}

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

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

void test(const char* str)
{
	printf("%s\n", str);
}

int main()
{
	void (*pf)(const char*) = test;//pf是函数指针变量
	void (*pfArr[10])(const char*);//pfArr是存放函数指针的数组
	void (*(*p)[10])(const char*) = &pfArr;//p是指向函数指针数组的指针
	
	return 0;
}

8. 回调函数

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

计算器的实现就可以用到回调函数:

#include 

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;
	int ret = 0;
	printf("请输入两个操作数:");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("ret = %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;
}

我们再举一个使用回调函数的例子:qsort函数(标准库中有一个函数qsort,是用来排序的)

说到排序,我们先来复习一下冒泡排序:

//冒泡排序
//有一组整数,需要排序为升序
//1. 两两相邻的元素比较
//2. 如果不满足顺序就交换

#include 

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

	}

}

int main()
{
	int arr[10] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;

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

	return 0;
}

但是我们会发现以上代码只适合于整型数据,而qsort函数就可以解决这个问题。

qsort函数的特点:

  1. 使用了快速排序的方法
  2. 适合于任意类型数据的排序

接下来,我们就学习一下如何使用qsort函数:
指针进阶(2)_第1张图片

void qsort(void* base,//指向了需要排序的数组的第一个元素
           size_t num,//排序的元素个数
           size_t size,//一个元素的大小,单位是字节
           int (*compar)(const void*, const void*)//函数指针类型 - 这个函数指针指向的函数,能够比较base指向数组中的两个元素
          );

这里先对 void* 进行一个解释:

//void* 的指针 - 无具体类型的指针
//void* 类型的指针可以接收任意类型的地址
//这种类型的指针是不能直接解引用操作的
//也不能直接进行指针运算的

int main()
{
	int a = 10;
	float f = 3.14f;
	int* pa = &a;
	//char* pc = &a;//err
	void* pv = &a;
	pv = &f;
	//*pv;//err
	//pv++;//err

	return 0;
}

接着我们来看一下qsort函数具体是如何使用的:

#include 
#include 
#include 

int cmp_int(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);//通过改变p1和p2的位置来改变升降序
}

void print(int arr[], int sz)
{
	int i = 0;

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

}

//测试qsort排序整型数据
void test1()
{
	int arr[10] = { 3, 1, 5, 2, 4, 7, 9, 6, 8, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//默认是升序的
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr, sz);
}

//测试qsort排序结构体数据
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 test2()
{
	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50}, {"wangwu", 15} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}

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

void test3()
{
	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50}, {"wangwu", 15} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}

int main()
{
	test1();
	test2();
	test3();

	return 0;
}

学会了qsort函数如何使用,那么我们能不能自己模拟实现一个qsort函数呢?

因为目前我们还没有学习快速排序算法,所以我们使用冒泡排序的思想,实现一个功能类似qsort的函数bubble_sort:

  1. 使用冒泡排序的思想
  2. 适用于任意类型数据的排序

首先,通过观察我们之前写的冒泡排序代码,我们发现它的参数只能接收整型数组,因此,我们需要使用一个 void* 的指针;同时,作为代码的实现者,我们不知道 void* 的指针指向的数组元素是什么类型的,所以我们还需要知道数组中一个元素的大小。

其次,对于不同类型的数据,不能简单地使用 > 比较,所以我们要在参数部分加上函数指针cmp,将实现2个元素比较的这一个函数的地址,以参数的形式传递过来。

最后,不同的数据,在交换的时候也略有差异,具体应该怎么实现,在写代码的时候再进行讲解。

#include 

//每个元素的首地址和一个元素的大小我们都知道,因此,我们可以通过一个字节一个字节的交换,来实现两个元素的交换(这样就能解决不同数据在交换时候的差异了)
void Swap(char* buf1, char* buf2, int size)//交换下标为j和j+1的这两个元素
{
	int i = 0;
	char tmp = 0;

	for (i = 0; i < size; i++)
	{
		tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}

}

void bubble_sort(void* base, int num, int size, int (*cmp)(const void*, const void*))
{
	int i = 0;
	//趟数
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		//一趟内部比较的对数
		for (j = 0; j < num - 1 - i; j++)
		{
			//假设需要升序,cmp返回>0,交换
			if (cmp((char*)base+j*size, (char*)base+(j+1)*size) > 0)//两个元素比较,需要将下标为j和j+1的元素的地址传给cmp
			{
				//交换
				Swap((char*)base+j*size, (char*)base+(j+1)*size, size);
			}
		}

	}

}

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

//测试bubble_sort 排序结构体数据	
void test2()
{
	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50}, {"wangwu", 15} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}

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

void test3()
{
	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50}, {"wangwu", 15} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}

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

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

int main()
{
	test1();
	test2();
	test3();

	return 0;
}

你可能感兴趣的:(C语言,算法,c语言,数据结构,开发语言)