函数指针与回调函数

目录

1. 函数指针

2. 回调函数

3. 指针函数

---

百度权威解释回调函数：

1. 回调函数是一个通过函数指针调用的函数。

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

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

eg1：函数指针与回调函数

#include 

void print();

int main()
{
    void(* fuc)();
    fuc = print;
    fuc();
}

void print()
{
    printf("hello world! \n");
}

详解上述例子：

从上述例子可以看到，首先定义了一个函数指针fuc，其返回值为void型，然后给函数指针赋值为print，也就是print函数的首地址，此时fuc获得了print的地址，fuc的地址等于print的地址，所以最终调用" fuc(); " 也就相当于调用了printf()。 

然而这个例子明显和百度的解释不符？定义是：如果把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。虽然有所不同，但道理是一样的。

eg2：函数指针与回调函数_加深

  #include 
  #include 

  void printWelcome()
  {
    printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
  }

  int main()
  {
    //1.如何定义函数指针
    void (*p2)();  
    //1.如何表示指针：*  
    //2.如何知道是函数:()  
    //3.函数指针是专用的，格式要求很强（参数类型，个数，返回值），就像数组指针一样

    //2.如何给函数指针赋值
    p2 = printWelcome;  //函数就是地址，就像数组一样，数组名就是地址
    合并写 // void (*p2)() = printWelcome;

    //3.如何通过函数指针调用函数，两种调用方法
    p2();  //直接通过指针名字 + () //AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
    //(*p2)();  //取函数内容 (*指针名字)()
    
    system("pause");
    return 0;
  }

eg3：函数指针与回调函数_带参数

  #include 
  #include 

  int add(int a, int b)
  {
    return a + b;
  }

  int main()
  {
    int (*padd)(int a, int b);
    padd = add;
    int ret = padd(1,2);
    //int ret = (*padd)(1,2);
    printf("ret = %d\n",ret); //3
    
    system("pause");
    return 0;
  }

 eg4：函数指针与回调函数_进阶篇

#include 

void add_ret();

int add(int a, int b, int(* add_value)())
{
    return(* add_value)(a,b);
}

int main()
{
    int sum;
    sum = add(3, 4, add_ret);
    printf("sum: %d\n", sum);  //7
    return 0;
}

void add_ret(int a, int b)
{
    return a + b;
}

详解上述例子：

从该例子可以看出，首先把函数的指针（地址），这里也就是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，developer.c，developer.h。其中：

main.c是用户开发的。

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

main.c

#include 
#include "developer.h"

void add_ret(int a, int b)
{
    return a + b;
}

int main()
{
    int sum;
    sum = add(3, 4, add_ret);
    printf("sum: %d\n", sum);  //7
    return 0;
}

developer.c

#include 

int add(int a, int b, int(* add_value)())
{
    return (* add_value)(a, b)
}

developer.h

# ifndef __DEVELOPER_H
# define __DEVELOPER_H

int add(int a, int b, int(* add_value)());

# endif

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

如何制作动态库，请自行研究......

---

1. 函数指针

在Linux内核中，有一个结构体是用来描述文件操作的。首先来看这个结构体，这段代码位于Linux内核的include/linux/fa.h中，由于代码众多，这里只截取几个最基本的例子：

file_operations文件操作结构体：

struct file_operations {
	struct module *owner;
	loff_t (*llseek) (struct file *, loff_t, int);
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
	ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
	int (*iterate) (struct file *, struct dir_context *);
	int (*iterate_shared) (struct file *, struct dir_context *);
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
	int (*mmap) (struct file *, struct vm_area_struct *);
	int (*open) (struct inode *, struct file *);
	......
} ;

这段代码中，利用结构体的封装思想，将函数指针封装在一个file_operations结构体中，然后，在具体实现驱动时，实现具体的函数，再赋值给结构体中的函数指针做好初始化操作。

以下这段代码截取友善之臂提供的Linux内核中的tiny4412_adc.c 

//相当于结构体初始化的操作
static struct file_operations adc_dev_fops = {
    owner:  THIS_MODULE,
    open:   exynos_adc_open,
    read:   exynos_adc_read,
    unlocked_ioctl:  exynos_adc_ioctl,
    release:  exynos_adc_release,
};
static struct miscdevice misc = {
    .minor  = MISC_DYNAMIC_MINOR,
    .name   = "adc"，
    .fops   = &adc_dev_fops,
};

首先，定义 一个结构体变量，并对其进行初始化，在这个驱动中，只实现了ioctl函数，对照上面的结构体，unlocked_ioctl就是结构体中的函数指针。

long(* unlocked_ioctl)(struct file *, unsigned int, unsigned long);

再来看看友善之臂实现的led驱动中，也是这样做的，这也是C语言结构体的一种初始化方式，是合理的。

//相当于结构体初始化的操作
static struct file_operations tiny4412_led_dev_fops = {
    .owner   =   THIS_MODULE,
    .unlocked_ioctl  =  tiny4412_leds_ioctl,
};

在内核中，有很多这样的函数指针。 

2. 回调函数

再来看回调函数在Linux内核中的基本应用。

回调函数的本质就是函数指针，只不过定义有所区别。它的定义就是：把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，就说这是回调函数。

POSIX线程（POSIX threads，简称Pthreads），是线程的POSIX标准。该标准定义了创建和操作线程的一整套API。在类Unix操作系统（Unix、Linux、Mac OS X等）中，都使用Pthreads作为操作系统的线程。Windows操作系统也有其移植版pthreads-win32[1]。pthreads_create的原型如下：

int pthread_creata(pthread_t *thread, const 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环境多线程中的应用。

下面是一个测试pthreads.c

#include 
#include 

void *function(void *args)
{
    while(1)
    {
        printf("pthread1 form function\n");
        sleep(1);
    }
} 

int main(void)
{
    pthread_t tid;

    tid = pthread_creata(&tid, NULL, function, NULL);

    while(1)
    {
        printf("pthread2 form main\n");
        sleep(1);
    }

    return 0;
}

运行结果：

pthread1 form function

pthread2 form main

pthread1 form function

pthread2 form main

......

在这里，由于 标准C库没有包含线程库，所以编译这个程序时需要加上一个 -lpthread 的参数才可以编译通过。

可以看到，在main函数里的 printf 和在线程回调函数里的 printf 同时进行。

3. 指针函数

指针函数是指带指针的函数，即本质是一个函数。

指针函数返回值是某一类型的指针。

指针函数的定义

        返回类型标识符 * 函数名（形参列表）{函数体}

指针函数和局部变量返回。

static 局部静态变量，不是存储在栈空间中，是存储在数据段的静态存储区中，生命周期不是限于这个函数，而是限于整个程序的生命周期。