本文主要讲解关于函数指针以及回调函数相关问题，同时对C自带qsort函数进行剖析与改写，技术有限若有问题请指正
一、函数指针
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}这段代码打印的都是函数的地址，若想通过地址调用函数，则需要一个指针指向函数，即：void(*p)() // p先和指针结合，表明是一个指针，后面括号即声明了一个函数，返回值为void
C陷阱和缺陷中给了这两段函数：
//代码1
(*(void (*)())0)();
// void(*)() 函数指针 将0强制类型转换，取0地址处的函数
//
代码
2
void
(
*
signal
(
int
,
void
(
*
)(
int
)))(
int
);
// void(*)(int) 函数指针 形参为int 返回类型为void
// signal(int,void(*)(int)) signal函数，形参为（int ,void(*)(int)
// void(* signal(...))(int)
对代码2进行简化：
typedef void(*pfun_t)(int);
pfun_t signal(int,pfun_t);
1.2 函数指针数组：把函数的地址存到一个数组中，这个数组称为函数指针数组
1.2.1函数指针数组定义
int(*parr[10])() //parr先与[]结合，说明parr是一个数组，数组的内容是int(* )()
//int(*)() 为函数指针1.2.2函数指针数组的用途：转移表
实例：实现一个计算器
①传统写法
void menu()
{
printf("****************\n");
printf("****************\n");
printf("***1.add 2.sub**\n");
printf("***3.mul 4.div**\n");
printf("****************\n");
}
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 input = 0;
int a = 0;
int b = 0;
int ret = 0;
menu();
printf("请输入你需要的操作: ");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入两个数:");
scanf("%d %d", &a, &b);
ret= Add(a, b);
printf("%d", ret);
break;
case 2:
printf("请输入两个数:");
scanf("%d %d", &a, &b);
Sub(a, b);
printf("%d", ret);
break;
case 3:
printf("请输入两个数:");
scanf("%d %d", &a, &b);
Mul(a, b);
printf("%d", ret);
break;
case 4:
printf("请输入两个数:");
scanf("%d %d", &a, &b);
Div(a, b);
printf("%d", ret);
break;
}
}
使用switch case...语句来调用函数，但是代码看起来冗余，对传统写法进行修改
②第一步改进：使用函数指针数组，根据函数指针数组下标找到函数地址，对函数进行调用。此时函数指针数组相当于一个跳板- -转移表
#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;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
while (input)
{
printf( "*************************\n" );
printf( " 1:add 2:sub \n" );
printf( " 3:mul 4:div \n" );
printf( "*************************\n" );
printf( "请选择：" );
scanf( "%d", &input);
if ((input <= 4 && input >= 1))
{
printf( "输入操作数：" );
scanf( "%d %d", &x, &y);
ret = (*p[input])(x, y); //对函数指针进行解引用，找到对应函数地址
}
else
printf( "输入有误\n" );
printf( "ret = %d\n", ret);
}
return 0;
}二、回调函数
回调函数的定义：回调函数就是一个通过函数指针调用的函数。如果将函数的指针（地址）作为参数传递给另一个函数，当这个指针用来调用其所指向的函数时，就称这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时，由另一方调用的，用于对该事件或条件的响应。
1.冒泡排序
传统的冒泡排序写法如下：
如现在有一个数组arr[10] = {2,8,7,5,6,9,3,1,4},对它进行升序排序，冒泡排序的原理是：两两进行比较，若不符合顺序，则交换位置
第一趟排序：2,7,8,5,6,9,3,1,4
2,7,5,8,6,9,3,1,4
2,5,7,8,6,9,3,1,4
2,5,7,6,8,9,3,1,4
2,5,6,7,8,9,3,1,4
2,5,6,7,8,3,9,1,4
...
2,5,6,7,8,3,1,4,9
每趟将一个数放到最后的位置，一共10个数，则需要9趟。即n个数，需要n-1趟。
每趟中两两进行比较，10个数第一趟比较9次，第二趟8次...,即每趟比较次数(n-1-i)次。
实现代码如下：
这段代码将数组中的数进行降序排序，此段代码中将排序的形参固定，即只能排序整型数组
void print(int arr[ ], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
void bubble_sort_test(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++)
{
int tmp = 0;
if (arr[j] < arr[j + 1])
{
tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
print(arr, sz);
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort_test(arr, sz);
}2.qsort()函数剖析
首先剖析qsort()函数，进入cplusplus网站，网址如下：https://cplusplus.com/
源码如下： #include<stdlib.h>
void qsort (void* base, //要排序的数据元素的起始位置
size_t num, //要排序的元素个数
size_t size, //待排序的元素的大小
int (*compar)(const void*,const void*)); //函数指针，指向compar函数
//该函数返回值为空，而是修改数组的内容，该数组是通过compar定义的函数进行重新排序具体的compa实现排序定义如下：两个形参指向要比较的元素，返回类型为int
具体的 p1 >p2 返回 >0; p1 <p2 返回 <0 ; p1 = p2 return 0;
void * 可以指向任意类型，但是不可以直接解引用，需要强制类型转换后再解引用
具体地，对函数进行改写时候，将p1强制类型转换为待排序的类型，再进行解引用比较大小；
更具体地，int类型使用 > < 进行比较
str类型使用strcmp函数
strcut类型可以自定义比较方式
官方示例使用代码如下：
/* qsort example */
#include <stdio.h> /* printf */
#include <stdlib.h> /* qsort */
int values[] = { 40, 10, 100, 90, 20, 25 };
int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}
int main ()
{
int n;
qsort (values, 6, sizeof(int), compare);
for (n=0; n<6; n++)
printf ("%d ",values[n]);
return 0;
}3.对qsort()的改写，实现一个比较函数
int_cmp(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
int main()
{
int arr[] = { 1,3,5,7,9,2,4,6,8,0 };
int i = 0;
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}4.使用回调函数,模拟实现qsort(冒泡的方式)
自定义函数bubble_sort(),模拟实现qsort，则参数及返回类型要一致
qsort(void* base,size_t num,size_t size,int(*cmp)(const void * ,const void *)
//对数组进行排序
//数组的地址，数组元素个数，数据大小，要比较的方式
bubble_sort(arr,sizeof(arr)/sizeof(arr[0]),sizeof(arr[0]),cmp_int)对int(*cmp)(const void *, const void *)进行查阅
两个参数即要比较的数据，传入地址;返回类型为int
则具体的比较方式如下：
int cpm_int(const void * e1,const void *e2)
{
//两个整型数据比较大小
return (*(int *)e1 -*(int *)e2);
}比较之后若不符合顺序，进行交换，交换时不知道数据类型，先访问到地址，按照字节进行交换，具体的Swap函数如下：
void Swap(char *buf1, char *buf2,int width)
{
for (int i = 0; i < width; i++) // width 交换多少对
{
char tmp = *buf1; //单个字节交换
*buf1 = *buf2;
*buf2 = tmp;
buf1++; //下一个字节
buf2++;
}
}完整的代码如下：
void print(int arr[ ], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
void Swap(char *buf1, char *buf2,int width)
{
for (int i = 0; i < width; i++) // width 交换多少对
{
char tmp = *buf1; //单个字节交换
*buf1 = *buf2;
*buf2 = tmp;
buf1++; //下一个字节
buf2++;
}
}
int cmp(const void* e1, const void* e2)
{
return (* (int*)e1 - *(int*)e2);
}
void bubble_sort(void* base, int sz, int width, int (*cmp) (const void* e1, const void* e2))
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
//具体的比较函数
//cmp()将两个元素的地址传参,即传递arr[j] 与arr[j+1]
//base 为void * char类型为1个字节 (char *)base +偏移量
if(cmp( (char *)base+j*width,(char *)base+(j+1)*width) >0 )
//要升序的话 交换
// e1 > e2 return >0
{
//交换
// 07 00 00 00
// 06 00 00 00
//使用字节进行交换
Swap((char*)base + j * width, (char*)base + (j + 1) * width,width); //width是宽度
}
}
}
}
int main()
{
int arr[] = { 1,3,5,7,9,2,4,6,8,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), cmp);
print(arr, sz);
printf("\n");
return 0;
}总结
本文主要讲解关于函数指针以及回调函数相关问题，同时对C自带qsort函数进行剖析与改写，技术有限若有问题请指正。
扫一扫
1136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
