首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >深入浅出剖析C语言函数指针与回调函数

深入浅出剖析C语言函数指针与回调函数

作者头像
杨源鑫
发布2019-07-04 15:23:21
1.8K0
发布2019-07-04 15:23:21
举报
文章被收录于专栏:嵌入式开发圈嵌入式开发圈

一、C语言回调函数

什么是回调函数? 百度的权威解释如下:

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

 1#include <stdio.h>
 2void print();
 3int main(void)
 4{
 5    void (*fuc)(); 
 6    fuc = print ; 
 7    fuc();  
 8} 
 9void print()
10{
11    printf("hello world!\n");
12}

运行结果:

从这个例子可以看到,我们首先定义了一个函数指针fuc ,这个函数指针的返回值为void型,然后我们给函数指针赋值,赋值为print,也就是print函数的首地址,此时fuc获得了print的地址,fuc的地址等于print的地址,所以最终调用fuc();也就相当于调用了print();那么我写的这个例子明显和百度解释的不符合啊?定义是如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数,确实,有所不同,但道理是一样的,我们接下来再来看一个例子。

 1#include <stdio.h>
 2
 3int add_ret() ;
 4
 5int add(int a , int b , int (*add_value)())
 6{
 7    return (*add_value)(a,b);
 8}
 9
10int main(void)
11{
12    int sum = add(3,4,add_ret);
13    printf("sum:%d\n",sum);
14    return 0 ;
15} 
16
17int add_ret(int a , int b)
18{
19    return a+b ;
20}

运行结果:

从这个例子里,我们看到: 这样子不就符合我们的定义了嘛?我们把函数的指针(地址),这里也就是add_ret,作为参数int add(int a , int b , int (add_value)()) , 这里的参数就是int(add_value)() , 这个名字可以随便取,但是要符合C语言的命名规范。当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。 我们看到add函数内部,return (add_value)(a,b) ; 这个(add_value)(a,b)相当于对指针进行了简引用,我们在main函数中,传入具体要实现功能的函数,add_ret,这个函数很简单,就是实现两数相加并返回,这里刚刚好,简引用,相当于取出指针返回地址里的值,这个值就是return a+b,也就是我们传入a和b两数相加的结果。

那么,回调函数究竟有什么作用呢?

说到这里,就有了用户和开发者之间的概念,假设,用户是实现add_ret这个函数,而开发者是实现add这个函数,现在的需求是,用户将add_ret这个函数以参数的形式传入开发者实现的add函数,add函数就会返回一个数字给用户,开发者没必要告诉用户他实现了什么东西,用户也并不知道开发者是怎么实现的,用户只需要传入自己写的函数,便可以得到开发者实现的函数的返回值,开发者可以将内容封装起来,将头文件以及库文件提供给用户。

接下来,我们用Linux来演示下这个结果,我们在目录下创建三个文件main.c,vendor.c,vendor.h

main.c是用户开发的。

vendor.c和vendor.h是开发者实现的。

在main.c中,代码如下:

 1#include <stdio.h>
 2#include "vendor.h"
 3
 4int add_ret(int a , int b)
 5{
 6        return a + b ;
 7}
 8
 9int main(void)
10{
11    int sum = add(3,4,add_ret);
12    printf("sum:%d\n",sum);
13    return 0 ;
14}

vendor.c,代码如下:

1#include "vendor.h"
2int add(int a , int b , int (*add_value)())
3{
4        return (*add_value)(a,b);
5}

vendor.h,代码如下:

1#ifndef __VENDOR_H
2#define __VENDOR_H
3
4int add(int a , int b , int (*add_value)());
5
6#endif 

接下来,我们制作一个动态链接库,最终开发者把vendor.c的内容封起来,把vendor.h提供给用户使用。

 1#include <stdio.h>
 2#include "vendor.h"
 3
 4int add_ret(int a , int b)
 5{
 6        return a + b ;
 7}
 8
 9int main(void)
10{
11    int sum = add(3,4,add_ret);
12    printf("sum:%d\n",sum);
13    return 0 ;
14}

在linux下制作动态链接库,将vendor.c和vendor.h打包成一个动态链接库

先明白以下几个命令是什么意思:

生成动态库:

gcc -shared -fPIC dvendor.c -o libvendor.so

参数含义:

-shared : 生成动态库;

-fPIC : 生成与位置无关代码;

-o :指定生成的目标文件;

使用动态库:

gcc main.c -L . –lvendor -o main

-L : 指定库的路径(编译时); 不指定就使用默认路径(/usr/lib/lib)

-lvendor : 指定需要动态链接的库是谁;

代码运行时需要加载动态库:

./main 加载动态库 (默认加载路径:/usr/lib /lib ./ …)

./main

我们将编译动态库生成的libvendor.so拷贝到/usr/lib后,现在就不需要vendor.c了,此时我们将vendor.c移除,也可以正常的编译并且执行main函数的结果,这就是回调函数的作用之一。

操作流程如下:

二、回调函数在Linux内核中的应用

回调函数在Linux内核里得到了广泛的应用,接下来,我将引用Linux内核中文件操作结构体来详细的说明。 我们首先来看到这个结构体,这段代码位于linux内核的include/linux/fs.h中,由于代码众多,我只截取几个最基本的例子: File_operations文件操作结构体:

 1struct file_operations {
 2    struct module *owner;
 3    loff_t (*llseek) (struct file *, loff_t, int);
 4    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 5    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
 6    ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 7    ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 8    int (*readdir) (struct file *, void *, filldir_t);
 9    unsigned int (*poll) (struct file *, struct poll_table_struct *);
10    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
11    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
12    int (*mmap) (struct file *, struct vm_area_struct *);
13    int (*open) (struct inode *, struct file *);
14    int (*flush) (struct file *, fl_owner_t id);
15    int (*release) (struct inode *, struct file *);
16    int (*fsync) (struct file *, loff_t, loff_t, int datasync);
17    int (*aio_fsync) (struct kiocb *, int datasync);
18    int (*fasync) (int, struct file *, int);
19    int (*lock) (struct file *, int, struct file_lock *);
20    ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
21    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
22    int (*check_flags)(int);
23    int (*flock) (struct file *, int, struct file_lock *);
24    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
25    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
26    int (*setlease)(struct file *, long, struct file_lock **);
27    long (*fallocate)(struct file *file, int mode, loff_t offset,
28              loff_t len);
29};

这段代码中,利用结构体的封装思想,将函数指针封装在一个file_operations结构体里,然后,在具体实现驱动的时候,实现具体的函数,再赋值给结构体里的函数指针做好初始化操作,我们来看看友善之臂的led驱动就明白了。 以下这段代码截取友善之臂提供的linux内核中的tiny4412_led.c

 1static struct file_operations tiny4412_led_dev_fops = {
 2    .owner          = THIS_MODULE,
 3    .unlocked_ioctl = tiny4412_leds_ioctl,
 4};
 5
 6static struct miscdevice tiny4412_led_dev = {
 7    .minor          = MISC_DYNAMIC_MINOR,
 8    .name           = DEVICE_NAME,
 9    .fops           = &tiny4412_led_dev_fops,
10};

首先,先是定义了一个结构体变量,并对结构体变量进行初始化,在这个驱动中,只实现了ioctl函数,对照着上面的结构体,ulocked_ioctl就是结构体中的这个函数指针。 long (*unlocked_ioctl) (struct file *,unsigned int, unsigned long); 再来看看友善实现的adc驱动里,也是这么来做,这里看到 : 也是C语言结构体的一种初始化方式,也是合理的。

 1static struct file_operations adc_dev_fops = {
 2    owner:  THIS_MODULE,
 3    open:   exynos_adc_open,
 4    read:   exynos_adc_read,    
 5    unlocked_ioctl: exynos_adc_ioctl,
 6    release:    exynos_adc_release,
 7};
 8static struct miscdevice misc = {
 9    .minor  = MISC_DYNAMIC_MINOR,
10    .name   = "adc",
11    .fops   = &adc_dev_fops,
12};

在内核中,有很多这样的函数指针,所以,当我们了解了这样的套路以后,再去学习linux内核,我们的思想就会清晰很多了。 再来看看回调函数在linux内核里的基本应用。 从上节我们了解到,回调函数的本质其实也就是函数指针,只不过定义有所区别。它的定义就是:你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。 接下来我们来看一个例子: 这段代码摘自友善之臂的button驱动:

 1static int tiny4412_buttons_open(struct inode *inode, struct file *file)
 2{
 3    int irq;
 4    int i;
 5    int err = 0;
 6
 7    for (i = 0; i < ARRAY_SIZE(buttons); i++) {
 8        if (!buttons[i].gpio)
 9            continue;
10
11        setup_timer(&buttons[i].timer, tiny4412_buttons_timer,
12                (unsigned long)&buttons[i]);
13
14        irq = gpio_to_irq(buttons[i].gpio);
15        err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH, 
16                buttons[i].name, (void *)&buttons[i]);
17        if (err)
18            break;
19    }
20
21    if (err) {
22        i--;
23        for (; i >= 0; i--) {
24            if (!buttons[i].gpio)
25                continue;
26
27            irq = gpio_to_irq(buttons[i].gpio);
28            disable_irq(irq);
29            free_irq(irq, (void *)&buttons[i]);
30
31            del_timer_sync(&buttons[i].timer);
32        }
33
34        return -EBUSY;
35    }
36
37    ev_press = 1;
38    return 0;
39}

我们在tiny4412_buttons_open函数里看到

1err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH,
2                                 buttons[i].name,(void *)&buttons[i]);

我们来看看request_irq这个函数:

1static inline int __must_check
2request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
3        const char *name, void *dev)
4{
5    return request_threaded_irq(irq, handler, NULL, flags, name, dev);
6}

到这里我们就明白了,第二个参数是一个用typedef重新定义的一个新类型的函数指针。 那么也就是说一旦执行了tiny4412的open函数,就会通过request_irq去通过回调函数去执行按键中断,并返回一个中断句柄。这个回调函数,其实就是一个中断服务函数。

1static irqreturn_t button_interrupt(int irq, void *dev_id)
2{
3    struct button_desc *bdata = (struct button_desc *)dev_id;
4
5    mod_timer(&bdata->timer, jiffies + msecs_to_jiffies(40));
6
7    return IRQ_HANDLED;
8}

回调函数在内核中就是这么来使用的,当然,还有其它的,比如我们在tiny4412的open函数里面还看到:

1   setup_timer(&buttons[i].timer,tiny4412_buttons_timer,
2              (unsignedlong)&buttons[i]);

这个函数的作用是注册一个定时器,通过回调函数tiny4412_buttons_timer来进行触发。 如果你不看它的定义,你可能以为它是一个普通函数,其实它是一个宏封装的。

1#define setup_timer(timer, fn, data)                    \
2    do {                                \
3        static struct lock_class_key __key;         \
4        setup_timer_key((timer), #timer, &__key, (fn), (data));\
5    } while (0)

这个宏函数通过调用setup_timer_key这个函数来实现定时器的注册:

 1static inline void setup_timer_key(struct timer_list * timer,
 2                const char *name,
 3                struct lock_class_key *key,
 4                void (*function)(unsigned long),
 5                unsigned long data)
 6{
 7    timer->function = function;
 8    timer->data = data;
 9    init_timer_key(timer, name, key);
10}

通过这个例子,我们更加了解到回调函数在Linux内核中的应用,为学习Linux内核,分析linux内核源代码打下了基础。

三、回调函数在Posix应用API中的使用 其实,在Posix应用编程里,我们也能用到回调函数,我们来看看多线程编程中,经常使用的pthread_create函数: 我们先来看看它的原型:

1int  pthread_create((pthread_t *thread,  pthread_attr_t  *attr,  void  *(*start_routine)(void *),  void  *arg)

参数说明:

(1) thread:表示线程的标识符

(2) attr:表示线程的属性设置

(3) start_routine:表示线程函数的起始地址

(4) arg:表示传递给线程函数的参数

函数的返回值为:

(1) success:返回0

(2) fair:返回-1

看到这个函数的第三个参数,这不就是一个函数指针,同时也是一个回调函数嘛!这就是函数指针和回调函数在UNIX环境多线程编程中的应用。

我们在windows的dev C++上写一个测试程序来看看:

 1#include <stdio.h>
 2#include <pthread.h>
 3
 4
 5void *function(void *args)
 6{
 7    while(1)
 8    {
 9        printf("hello world1!\n");
10        sleep(1);
11    }
12}
13int main(void)
14{
15    pthread_t tid ;
16    tid = pthread_create(&tid , NULL , function , NULL);
17    while(1)
18    {
19        printf("hello world!\n");
20        sleep(1);
21    }
22    return 0 ;
23}

运行结果:

我们会看到在main函数里的打印语句和在线程回调函数void *function(void *args)里打印语句在同时打印。 关于这个函数的如何使用,网上文章有很多讲得非常的详细,这里仅仅只是写函数指针和回调函数的应用,详细可以参考这篇文章,了解进程和线程。 http://blog.csdn.net/tommy_wxie/article/details/8545253

当然,应用里还有其它的API通用运用到了回调函数,期待大家在实践中去发掘。

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2019-02-28,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 嵌入式开发圈 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档