写点什么

【指针内功修炼】函数指针 + 函数指针数组 + 回调函数(二)

作者:Albert Edison
  • 2022 年 9 月 16 日
    四川
  • 本文字数:7362 字

    阅读完需:约 24 分钟

【指针内功修炼】函数指针 + 函数指针数组 + 回调函数(二)

1. 函数指针

函数指针,顾名思义,就是指向函数的指针,函数 有没有地址呢?


#include <stdio.h>
void test(){ printf("hehe\n");}
int main(){ printf("%p\n", test); printf("%p\n", &test); return 0;}
复制代码


运行结果👇



在数组里面,数组名 拿到首元素的地址;&数组名 拿到整个数组的地址。


在函数里面,函数名&函数名 拿到的都是函数的地址,函数是没有首元素概念的。


函数的地址,就是函数存放的位置


那么函数的地址用什么来接收呢?代码如下👇


int Add(int x, int y){  return x + y;}
void test(char* str){}
int main(){ int arr[5]; int (*pa)[5] = &arr; //pa是数组指针 int (* pf)(int, int) = &Add; // pf是函数指针 int (* pf)(int, int) = Add; // 也可以直接用函数名
void (*pt)(char*) = test;
return 0;}
复制代码


pf 旁边放一颗 *,说明它是指针,指针指向的是函数,函数的参数类型是 intint,返回类型也是 int


当然函数也有无返回类型,pt 先和 * 结合,说明 pt 是指针,指针指向的是一个函数,指向的函数无参数,返回值类型为 void。


那么我们如何调用这个函数呢?我们以 pf 为例👇



阅读两段有趣的代码:



代码一:


1、把 0 强制类型转换为 void (*)() 类型的函数指针 2、再去调用 0 地址处这个参数为 无参,返回类型是 void 的函数 这是依次函数调用,调用 0 地址处的函数


代码二:


signal 是一个函数声明; 这个函数的参数有 2 个,第一个是 int 类型,第二个是函数指针,该指针指向的函数参数 int,返回类型是 void; signal 函数的返回类型也是函数指针,该指针指向的函数参数 int,返回类型是 void


是不是觉得代码二很复杂?那能不能把它简化呢?


我们可以这样写


2. 函数指针数组

数组是一个存放相同类型数据的存储空间,那我们已经学习了指针数组,如下


int* arr[10];// 数组的每个元素是int*
复制代码


那要把函数的地址存到一个数组中,那这个数组就叫 函数指针数组,那函数指针的数组如何定义呢?


int (*parr1[10])();int *parr2[10]();int (*)() parr3[10];
复制代码


上面给出了 3 中定义方式,正确的是:parr1


parr1 先和 [ ] 结合,说明 parr1 是数组,数组的内容是什么呢?


int (*)() 类型的函数指针。

🍑 函数指针数组的用途

我们学习了 函数指针函数指针数组,那么在实际场景如何运用呢?


我们这里以一个 计算器 小程序为例


示例一


写一个计算机小程序,能够实现基本的四则运算


📝代码实现


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, y; 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"); } } while (input); return 0;}
复制代码


运行结果👇



这样子写法是完全正确的,但是如果我要实现 按位与按位或左移右移 呢?


那我岂不是又要去 mian 函数里面添加,这样子很麻烦,有没有化简实现呢?


这时候就需要用到使用 函数指针数组 去实现了;


示例二


对示例一的计算器进行化简升级


📝代码实现


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) = { 0, Add, Sub, Mul, Div };//pfArr是一个函数指针的数组,也叫转移表
do { menu(); printf("请选择:>"); scanf("%d", &input); if (input == 0) { printf("退出计算器\n"); break; } else if (input >= 1 && input <= 4) { printf("输入2个操作数:>"); scanf("%d %d", &x, &y); ret = pfArr[input](x, y); printf("ret = %d\n", ret); } else { printf("选择错误\n"); } } while (input);
return 0;}
复制代码


当然运算结果也肯定是一样的,这里就不演示了

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

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


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


如何定义?


这里给举个例子👇



可能看到这里还是有点懵😵


别急,我们把上面的 计算器 小程序重新来改进一下


📝代码实现


void menu(){  printf("**********************************\n");  printf("*****  1. add     2. sub     *****\n");  printf("*****  3. mul     4. div     *****\n");  printf("*****  0. exit               *****\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;}
void calc(int (*pf)(int, int)){ int x = 0; int y = 0; int ret = 0; printf("输入2个操作数:>"); 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;}
复制代码


当然运行结果肯定也和上面一样的


分析一下 calc 函数



main 函数里,我们传了 AddSubMulDiv,它们都是不同的函数地址,


那么在 calc 函数里面,我们要用指针 pf 来接收,函数类型是 intint,返回类型是 void

4. 回调函数

回调函数就是一个 通过函数指针调用的函数


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


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


在上面的 计算器 小程序中,我们没有直接的去调用 AddSubMulDiv 这四个函数,而且传给了 calc,当在 calc 函数内部时,准备了 2 个数去计算,我们直接通过 pf 指针去计算。


是不是有点难理解?别急,这里再通过几个示例来讲讲 回调函数

🍑 冒泡排序

一说到排序,脑海里面第一时间想到的都是冒泡排序,那么我这里就来写一个冒泡排序


📝代码实现


//冒泡排序void bubble_sort(int arr[], int sz) {  int i = 0;  int j = 0;  //趟数  for (i = 0; i < sz - 1; i++) {    //每一趟冒泡排序的过程    //确定的一趟排序中比较的对数    for (j = 0; j < sz - 1 - i; j++) {      if (arr[j] > arr[j + 1]) {        int tmp = arr[j + 1];        arr[j + 1] = arr[j];        arr[j] = tmp;      }    }  }}
void print(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); }}
int main(){ int arr[] = { 1,4,2,6,5,3,7,9,0,8 }; int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz);
print(arr, sz); return 0;}
复制代码


运行结果


🍑 qsort 排序

上面的冒泡排序使用起来当然很好,但是会存在一个问题,就是使用起来会很局限?


假设我要对 floatstruct 等其它类型的数据进行排序呢?


那么有没有一种现成的排序模板呢?


其实在 C 语言中有一个库函数叫 qsort,它是用快速排序的方法实现的。



里面有些参数是不需要用到的,整理一下,如下



第一个参数是 void 类型的指针;


第二个参数是 整型


第三个参数是 整型


第四个参数是 函数指针compare* 结合,说明它是指针,指针外面指向一个函数,该函数有 2 个参数,返回类型是 int


下面我们对参数进行分析



  • base


目标数组是开始。你要排序的数据的起始位置就需要传到 base 里面,


  • num


元素个数(数组大小)


  • width


元素的宽度,也就是一个元素占几个字节比如 int4 个字节、char1 个字节


  • compare


比较函数


  • elem1elem2


传给 compare 用来比较的元素


对于 compare,还要遵循几个因素



如果 elem1 指向的元素 小于 elem2 指向的元素,那么就返回 小于 0 的数字;


如果 elem1 指向的元素 大于 elem2 指向的元素,那么就返回 大于 0 的数字;


如果 elem1 指向的元素 等于 elem2 指向的元素,那么就返回 0

qsort 排序整型数组

了解 qsort 函数的基本情况以后,我们就来使用它,对上面的 arr 数组重新进行排序;


📝代码实现


#include <stdio.h>#include <stdlib.h>
void print(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); }}
void cmp_int(const void* e1, const void* e2) { return *(int*)e1 - *(int*)e2;}
int main(){ int arr[] = { 1,4,2,6,5,3,7,9,0,8 }; int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
print(arr, sz); return 0;}
复制代码


cmp_int 是创建的 比较函数 ,它的作用就是:比较 e1e2 指向的元素


*(int*)e1 :对 e1 强制类型转换为 int*, 然后解引用,访问一个字节;


*(int*)e2 :对 e2 强制类型转换为 int*, 然后解引用,再向后访问一个字节;


这里要讲一下关于 void* 的知识点


void* 是一种无类型的指针,无具体类型的指针 void* 的指针变量可以存放任意类型的地址 void* 的指针不能直接进行解引用操作 void* 的指针不能直接进行 +-整数

qsort 排序结构体

我们定义一个结构体,要求结构体里面有 姓名年龄成绩


要求使用 qsort 函数按照 成绩 来对结构体成员排序


📝代码实现


#include <stdio.h>#include <stdlib.h>
struct Stu{ char name[20]; int age; float score;};
int cmp_stu_by_socre(const void* e1, const void* e2){ if (((struct Stu*)e1)->score > ((struct Stu*)e2)->score) { return 1; } else if (((struct Stu*)e1)->score < ((struct Stu*)e2)->score) { return -1; } else { return 0; }}
void print_stu(struct Stu arr[], int sz){ int i = 0; for (i = 0; i < sz; i++) { printf("%s %d %f\n", arr[i].name, arr[i].age, arr[i].score); } printf("\n");}
void test1(){ struct Stu arr[] = { {"zhangsan",20,87.5f},{"lisi",22,99.0f},{"wangwu", 10, 68.5f} };
int sz = sizeof(arr) / sizeof(arr[0]);
// 按照成绩来排序 qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_socre); //打印结构体成员 print_stu(arr, sz); return 0;}
int main(){ test1(); return 0;}
复制代码


运行结果👇



还可以按照 年龄 来排序


📝代码实现


#include <stdio.h>#include <stdlib.h>
struct Stu{ char name[20]; int age; float score;};
int cmp_stu_by_age(const void* e1, const void* e2){ return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;}
void print_stu(struct Stu arr[], int sz){ int i = 0; for (i = 0; i < sz; i++) { printf("%s %d %f\n", arr[i].name, arr[i].age, arr[i].score); } printf("\n");}
void test1(){ struct Stu arr[] = { {"zhangsan",20,87.5f},{"lisi",22,99.0f},{"wangwu", 10, 68.5f} };
int sz = sizeof(arr) / sizeof(arr[0]);
// 按照年龄来排序 qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
print_stu(arr, sz); return 0;}
int main(){ test1(); return 0;}
复制代码


运行结果👇



当然,肯定还可以按照 姓名 来排序


📝代码实现


#include <stdio.h>#include <stdlib.h>
struct Stu{ char name[20]; int age; float score;};
int cmp_stu_by_name(const void* e1, const void* e2){ return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);}
void print_stu(struct Stu arr[], int sz){ int i = 0; for (i = 0; i < sz; i++) { printf("%s %d %f\n", arr[i].name, arr[i].age, arr[i].score); } printf("\n");}
void test1(){ struct Stu arr[] = { {"zhangsan",20,87.5f},{"lisi",22,99.0f},{"wangwu", 10, 68.5f} };
int sz = sizeof(arr) / sizeof(arr[0]); qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name); print_stu(arr, sz); return 0;}
int main(){ test1(); return 0;}
复制代码


运行结果👇



注意:名字 排序是根据首字母的 ASCII 码值来比较的;

模拟实现 qsort

既然学会了 qsort 函数的使用,那么我们来模仿 qsort 的功能实现一个通用的冒泡排序;


📝代码实现


#include <stdio.h>
int cmp_int(const void* e1, const void* e2){ return *(int*)e1 - *(int*)e2;}
void print_arr(int arr[], int sz){ int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("\n");}
void Swap(char* buf1, char* buf2, int width){ int i = 0; for (i = 0; i < width; i++) { char tmp = *buf1; *buf1 = *buf2; *buf2 = tmp; buf1++; buf2++; }}
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++) { if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0) { //两个元素的交换 Swap((char*)base + j * width, (char*)base + (j + 1) * width, width); } } }}
void test2(){ int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);}
int main(){ test2(); return 0;}
复制代码


运行结果👇



其实这段代码很简单,但是理解起来的话,还是有点难度,别急,下面我们一起来看一看


代码解析:


我们先来梳理一下调用逻辑:



首先我们从 test2 函数出发,在函数内部,调用 bubble_sort 函数


bubble_sort 函数的参数部分:


1、arr 传的就是数组第 1 个元素 9 的地址,形参部分用 base 接收


2、sz 就是元素个数 10,形参部分用 sz 接收


3、sizeof(arr[0]) 就是一个 int 的大小 4 个字节,形参部分用 width 接收


4、cmp_int 是一个函数,相当于传的就是函数的地址,形参部分用指针 cmp 接收,cmp 就指向创建的 cmp_int 函数


我们再来详细说下 bubble_sort 函数和 cmp_int 函数



我们在 if 语句里面传的两个值,其实通过 函数指针 跑去 cmp_int 函数里,调用 e1e2 去了;


(char*)base + j * width 传给了 e1(char*)base + (j + 1) * width 传给了 e2,然后 e1e2 进行计算,计算好之后的结果(返回类型是 int)再与 if 语句里面的 0 进行比较;


如果返回结果是 大于 0 的,说明 e1 大于 e2,那我们就把 e1e2 进行交换,而交换的时候,又去调用我们的 Swap 函数;


所以核心思路就是:把 cmp_int 函数的地址传给 bubble_sort,用一个 cmp 指针来接收,再通过这个 cmp 指针去调用这个函数的。


关于 Swap 函数,这里就不过多解释,其实就是个交换的实现。


❗ 这里在重点说一下:(char*)base + j * width, (char*)base + (j + 1) * width 这段代码


这里拿结构体代码来举例👇



首先我创建的结构体类型一共是 28 个字节;


test1 函数里,定义的 arr 一共有 3 个结构体,那么在内存中应该是下面这样👇



test1 函数里:


arr 传给了 basebase 相当于指向了第一个 28 的地址,但是如果我们要比较第一个 28 和第二个 28 呢?


是不是还需要 base 指向的下一个元素的地址



其实 问号 处的地址很简单,我们来看 bubble_sort 函数内部的 if 语句:


1、当 j = 0 时,也就是 ,宽度就是 sizeof(arr[0]) 的计算结果,也就是 28


所以就是:(char*)base + 0(char*)base + 28


因为我是 char* 强转之后的 base,所以 (char*) base + 0 还是首元素的地址;


因为我是 char* 类型的指针,所以 (char*) base + 28 跳过 28 个字节,因为这个结构体正好是 28 个字节👇



2、当 j = 1


就是:(char*) base + 1 * 28(char*) base + (1 + 1) * 28


因为我们是把 base 强制类型转换成了 char* 的指针,而 char* 的指针就可以理解为 1base 加多少,就跳过多少个字节的大小👇



发布于: 刚刚阅读数: 6
用户头像

Albert Edison

关注

目前在某大厂担任后端开发,欢迎交流🤝 2022.03.08 加入

🏅️平台:InfoQ 签约作者、阿里云 专家博主、CSDN 优质创作者 🛫领域:专注于C语言、数据结构与算法、C++、Linux、MySQL、云原生的研究 ✨成就:2021年CSDN博客新星Top9,算法领域优质创作者,全网累计粉丝4W+

评论

发布
暂无评论
【指针内功修炼】函数指针 + 函数指针数组 + 回调函数(二)_数组_Albert Edison_InfoQ写作社区