C语言中回调函数和qsort函数的用法详解

目录

• 回调函数
• 指向函数指针数组的指针
• qsort（qulick sort）-库函数

回调函数

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

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

举例：

#include<stdio.h>
void menu()
{
    printf("********************************\n");
    printf("**    1.and        2.sub      **\n");
    printf("**    3.mul        4.div      **\n");
    printf("********************************\n");
}
int add(int x, int y)
{
    int z = 0;
    z = x + y;
    return z;
}
int sub(int x, int y)
{
    int z = 0;
    z = x - y;
    return z;
}
int mul(int x, int y)
{
    int z = 0;
    z = x * y;
    return z;
}
int div(int x, int y)
{
    int z = 0;
    z = x / y;
    return z;
}
void Calc(int(*pf)(int, int))//int(*pf)(int, int)等于add,只不过选用不同的方式进行调用
{
    int x = 0;
    int y = 0;
    printf("请输入两个操作数:>");
    scanf_s("%d%d", &x, &y);
    printf("%d\n", pf(x, y));//通过指针对add函数进行调用，而不是像之前那样使用函数名进行调用
}
int main()
{
    int input = 0;
    do
    {
        menu();
        printf("请选择：>");
        scanf_s("%d", &input);
        switch (input)
        {
        case 1:
            Calc(add);//将add函数的地址传递过去，这里的add函数为回调函数
            break;
        case 2:
            Calc(sub);
        case 3:
            Calc(mul);
        case 4:
            Calc(div);

        }
    } while (input);
}

指向函数指针数组的指针

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

如何定义？

    int arr[10] = { 0 };//整型数组
    int(*p)[10] = &arr;//取出数组的地址
    int (*pf)(int, int);//函数指针
    int(*pfarr[4])(int, int);//pfarr是一个数组，函数指针的数组
    int(*(*ppfarr)[4])(int, int) = &pfarr;//ppfarr指向函数指针数组的指针
    //pfarr是一个数组指针，指针指向的数组有4个元素
    //指向的数组的每个元素的类型是函数指针int(*)(int,int)

void*

可以用来接收任何类型数据的地址，别名万能指针

既然可以存放任何类型的地址，那么是不是也可以解引用访问存放的值？

下面我们通过示例：

#include<stdio.h>
int main()
{
    int a = 10;
    void* p = &a;
    printf("%d\n", *p);
}

通过输出结果我们发现，程序并没有被正确的运行，而是告诉我们，我们进行了非法间接寻址。

那么为什么会出现这样的现象呢？

原因是void*虽然可以接受任意类型的地址，但它自己本身的类型是空类型，那么在解引用操作的时候，系统并不知道它的类型，因此不知道需要分配给其几个字节，指针类型决定了它的字节大小。

因此，void*不能进行解引用操作

那么可以进行++/–操作吗？

我们通过实例进行验证一下：

#include<stdio.h>
int main()
{
    int a = 10;
    void* p = &a;
    p++;
}

程序依然没有正确运行，编译器指出了错误的原因：void未知的大小，和上面一样的道理，我们并不清楚此时存放在void里面的数据是什么类型，自然也不知道它所占据内存空间的大小，因此步长是无法确定的。

因此void*也不可以进行++/–操作

qsort（qulick sort）-库函数

适用的场景：适用于对某一组数据进行快速排序

qsort(s,sz,sizeof(s[0]),cmp_stu_by_name);
//第一个参数s:待排序数组的首元素地址
//第二个参数sz：待排序数组的元素个数
//第三个参数sizeof(s[0]):待排序数组的每个元素的大小，单位是字节
//第四个参数：是函数指针，比较两个元素的所用函数的地址
//这个函数使用者自己实现函数指针的两个参数是：待比较的两个元素的地址

举例：

常规方法：冒泡排序：

#include<stdio.h>
int main()
{
    int arr[10] = { 9,2,3,1,4,5,7,6,0,91 };
    int i, j=0,temp;
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz-1; i++)//决定需要比较多少次
    {
        for (j=0; j < sz-1-i; j++)
        {
            if (arr[j+1] > arr[j])
            {
                temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

输出：

91 9 7 6 5 4 3 2 1 0

但是，这种方法的局限性非常大，执行效率也不高。

因此在进行数据类型的排序问题时，我们可以选择qsort函数：

下面我们就来学习qsort函数：

//int (*cmp)(const void *,const void *);
qsort(*s, n, sizeof(s[0]), cmp);

其中第一个参数s是一个地址，即参与排序的首地址； n是需要排序的数量； sizeof(s[0])则是每一个元素占用的空间大小；

指向函数的指针，用于确定排序的顺序。

sz=sizeof(arr)/sizeof(arr[0])
qsort(a, sz,arr[0], cmp);
//其中cmp函数应写为：
int cmp(const void *a, const void *b)//void*可接受任意类型的数据
{
    return *(int*)a - *(int*)b; //由小到大排序
    //return *(int *)b - *(int *)a; 由大到小排序
}

对于整形数据的比较实现过程：

#include<stdio.h>
#include<stdlib.h>#qsort的头文件
int cmp_int(const void* e1, const void* e2)//e1和e2是用来接收要比较的两个元素的地址
{
    return *(int*)e1 - *(int*)e2;
}
int main()
{
    int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    qsort(arr,sz, sizeof(arr[0]), cmp_int);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);//整形打印%d
    }
    return 0;
}

输出：

0 1 2 3 4 5 6 7 8 9

对于浮点型数据的比较实现过程：

int cmp_float(const void* e1, const void* e2)//e1和e2是用来接收要比较的两个元素的地址
//由于cmp_float函数的返回类型是int,因此，需要进行转化
{
     //可用if分支语句
    /*if (*(float*)e1 == *(float*)e2)
        return 0;
    else if (*(float*)e1 > *(float*)e2)
        return 1;
    else
        return 0;*/
        //也可用return直接返回
    return ((int) * (float*)e1 - *(float*)e2);
}
int main()
{
    float f[] = { 9.0,8.0,7.0,6.0,5.0,4.0 };
    int sz = sizeof(f) / sizeof(f[0]);
    qsort(f,sz, sizeof(f[0]), cmp_float);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%f ", f[i]);//浮点型打印%f
    }
    return 0;
}

对于结构体类型数据的实现过程：

结构体类型和整形浮点型在排序的时候有略微区别，结构体类型并不能直接进行比较，而要按照某一变量，例如：名字，年龄等等

按照年龄比较：

#include<stdio.h>
#include<stdlib.h>
struct stu//定义一个结构体
{
	char name[20];
	int age;
};

int cmp_s_stu(const void* e1, const void* e2)//e1和e2是用来接收要比较的两个元素的地址
{
	return ((struct stu*)e1)->age - ((struct stu*)e2)->age;//告诉编译器你想用什么样的方式进行排序
}
int main()
{
	struct stu s[3] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s,sz, sizeof(s[0]), cmp_s_stu);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s ", s[i]);#字符串型，以%s进行打印
	}
	return 0;
}

按照名字进行比较：

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

int cmp_s_stu(const void* e1, const void* e2)//e1和e2是用来接收要比较的两个元素的地址
{
	return strcmp(((struct stu*)e1)->name,((struct stu*)e2)->name);//比较名字就是比较字符串
	//注意字符串在比较大小的时候，不能直接用加减法进行比较，而要用strcmp()函数
}
int main()
{
	struct stu s[3] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s,sz, sizeof(s[0]), cmp_s_stu);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s ", s[i]);#字符串型，以%s进行打印
	}
	return 0;
}

到此这篇关于C语言中回调函数和qsort函数的用法详解的文章就介绍到这了,更多相关C语言 回调函数 qsort内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！