函数指针与指针函数(浅谈) C也能实现面向对象编程思维的关键

函数指针

函数指针在操作系统的内核代码中是非常常见的一种用法，其中用的比较广泛的是将其封装到一个结构体内部,然后关于该结构体进行扩展需求的开发

例如字符设备驱动开发中

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 *);
	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 (*mremap)(struct file *, struct vm_area_struct *);
	int (*open) (struct inode *, struct file *);
	int (*flush) (struct file *, fl_owner_t id);
	int (*release) (struct inode *, struct file *);
	int (*fsync) (struct file *, loff_t, loff_t, int datasync);
	int (*aio_fsync) (struct kiocb *, int datasync);
	int (*fasync) (int, struct file *, int);
	int (*lock) (struct file *, int, struct file_lock *);
	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
	int (*check_flags)(int);
	int (*flock) (struct file *, int, struct file_lock *);
	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
	int (*setlease)(struct file *, long, struct file_lock **, void **);
	long (*fallocate)(struct file *file, int mode, loff_t offset,
			  loff_t len);
	void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
	unsigned (*mmap_capabilities)(struct file *);
#endif
};

包括了，关于内存映射的设置，打开读写设备，非阻塞机制，io控制，异步通知等等，知识量非常庞大

(这里对于小白来看，会感觉比较恐怖，但是在操作系统底层，这只是冰山一角哈，这不是本次话题的主要内容，接下来进入正题)

指针函数和函数指针是C里两个比较绕的概念。实际应用中非常广泛。特别是当指针函数、函数指针，函数指针变量，构成更加复杂的数据结构时，比如，函数指针数组等，容易把人转晕。

定义

函数指针的本质是一个指针，该指针的地址指向了一个函数，即指向函数的指针。
函数的定义是存在于代码段，因此，每个函数在代码段中，也有着对应的入口地址，函数指针就是指向代码段中函数入口地址的指针。

/*
    return_type 为返回类型，
    ptr为指针变量，代表的是指向目标函数的指针
    args为形参列表，
    *ptr即为函数。
*/

return_type (*ptr)(args, ...);

初始化方式

#include <stdio.h>

int great(int a, int b)
{
    return a > b ? a : b;
}

int main(void)
{
    int (*ptr)(int, int);         //函数指针的定义
    //int (*ptr)();               //函数指针的另一种定义方式，不过不建议使用
    //int (*ptr)(int a, int b);   //也可以使用这种方式定义函数指针
    
    ptr = great;                  //函数指针初始化

    int ret = ptr(10, 15);        //函数指针的调用

    //int ret = (*great)(10,15);
    //int ret = (*ptr)(10,15);
    //以上两种写法与第一种写法是等价的，不过建议使用第一种方式

    printf("max = %d \n", ret);
    return 0;
}

这时可能有人疑惑了，明明函数的触发，直接调用great就行，为什么绕个圈去加个函数指针，再来调用great，其实道理和指针变量一样，指针存储着地址，极大地方便了操作原对象或者嵌套操作，当函数的嵌套调用时，指针作为变量传入参数进行进一步操作，可以使得工程实现更加复杂和稳定的功能。

最关键一点，关于函数指针，也是C实现诸如C++，面向对象操作的关键点，在C++中，因为类的三大特性，可以将成员函数的实现，封装到类中，在C里没有这个概念，但是可以通过函数指针，实现伪类，即在结构体中，封装函数指针，在结构体对象中进行具体的函数实现，比如本篇最初提到的那个字符驱动设备的文件结构体。

函数指针的另一个用处即是，实现回调函数

回调函数是一个通过函数指针调用的函数的函数。其将函数指针作为一个参数，传递给另一个函数。这么说有点拗口，下面举例介绍，其中优化后的bubblesort就是一个回调函数

(回调函数的目标函数的逻辑并不是直接调用(非函数调用)，而是在特定的事件或条件发生时由另外一函数来调用(使用地址)。参数为一个函数指针，通过该函数指针来调用目标函数，并把结果返回给主调函数)

把目标函数的逻辑直接调用，即在函数内调用函数，这在业界有另外一个名字，递归函数

回调函数

其简而言之就是一个被作为参数传递的函数

这样一个场景，在进行排序时，比如在冒泡排序中

void swap(int* arr1, int* arr2){
    int tmp = *arr1;
    *arr1 =  *arr2;
    *arr2 = tmp;
}

void bubblesort(int* arr, int len){
    for(int i  = 0; i< len-1; i++){
        for(int j = 0; j < len-i-1; j++){
            if(arr[j] > arr[j+1])
                swap(&arr[j], &arr[j+1]);
        }
    }
}

这时，如果有需求要将其做成库函数

在生成可执行程序后，如果想换个排序方向，即调整降序和升序，修改判断条件中 ＞或＜，那重新编译又将比较繁琐；

将函数指针作为形式参数，传入函数作为参数，优化这个排序，生成可执行程序后，在使用时可以根据附加条件，进行期待的升序或降序，那将可以避免重新编译；

int great(int num1, int num2){

    return (num1 > num2) ? 1:0;

}

int less(int num1, int num2){

    return (num1 < num2) ? 1 :0;
}


void bubblesort(int* arr, int len, int (*ptr)(int, int)){
    for(int i  = 0; i< len-1; i++){
        for(int j = 0; j < len-i-1; j++){
            if(ptr(arr[j], arr[j+1]))
                swap(&arr[j], &arr[j+1]);
        }
    }
}


void show_result(int *arr, int len){
    int i;
    for(i = 0; i < len; i++){
        printf("%d ", arr[i]);
    }
    printf("\r\n");
}

int main(int argc, char** argv){

    int array[LEN] = {6,8,4,2,5,3,7,9,1};

    if(argv[1] == ">")
        bubblesort(array, LEN, great);
    else if(argv[1] == "<")
        bubblesort(array, LEN, less);

    
    show_result(array, LEN);

    return 0;
}

这其中把函数作为参数来进行调用的函数，即称为  回调函数

/* 需要注意的一点*/

//一般调用函数指针所指向的函数，应该如下操作
(*ptr)();
//C允许写成如下形式，编译也是可通过的
ptr();

/*
    关于为什么函数作为参数传入时，不用使用调用的形式
    因为函数名即函数入口地址，而指针变量形参要求，参数是地址值
    因此在触发回调时，应该写成
    bubblesort(array, LEN, great);

    而不是
    bubblesort(array, LEN, great(var1, var2));

    之后关于其具体如何使用这个great实参，是触发回调的函数主体bubblesort内的设置逻辑了

*/

指针函数

简而言之，它的本质是一个函数，不过它的返回值是一个指针变量。

/*
    func是一个函数变量名，
    args是形参列表，
    return_type是一个指针变量,是func函数的返回值
*/
return_type *func(args, ...);

指针函数的作用主要体现在，对于多级指针的变量的修改，函数返回低一级指针的变量类型可以达到修改原数据的效果。(这句话例子比较罕见，当大家接触的工程量多了，一定会有所悟的哈)

一个简单的示例就是，通过函数进行动态内存分配

#include <stdio.h>

int* addIntegers(int a, int b) {
  int* result = (int*)malloc(sizeof(int));
  *result = a + b;
  return result;
}


int main(int argc, char** argv) {

  int* sum = addIntegers(5, 3);
  printf("sum as %d\n", *sum);
  free(sum);

  return 0;
}

这时大家又会问了，为什么搞那么麻烦，在函数里创建个指针变量来接收开辟的内存空间，然后返回让一个指针变量接收，貌似多此一举。

实际上这在程序开发中，是有意义的，因为进程的内存分布，一般函数里的变量称为局部变量(存放于栈区)，调用完，函数会释放其内存空间。当我们需要使用函数进行动态开辟空间时，即初始化构造一些数据，这个功能还是有意义的。

因此，在使用指针函数的时候，一定要避免出现返回局部变量指针的情况。

如果在函数内部定义一个变量，在使用一个指针去指向这个变量，当函数调用结束时，这个变量的空间就已经被释放，这时就算返回了该地址的指针，也不一定会得到正确的值。而如果是在堆空间创建的变量，其生命周期存在整个程序运行期间。

如果返回的是一个局部定义的变量，该变量已经被释放，很有可能该地址已经被其他的变量所占用，这时候得到的就不是想要的结果。甚至更严重的是，如果因此访问到了不可访问的内容，很有可能造成段错误等程序崩溃的情况。

当然可以使用关键字修饰，改变其生命周期，一旦使用了static去修饰变量，那么该变量就变成了静态变量。而静态变量是存放在数据段的，它的生命周期存在于整个程序运行期间，只要程序没有结束，该变量就会一直存在。

同时，还有一种解决方案是使用全局变量，因为全局变量也是放在数据段的，但是并不推荐使用全局变量，因为在多线程环境下，全局变量如果被多个线程访问，可能会出现竞争，需要比较繁琐的同步和互斥手段。

关于函数指针和指针函数的浅谈暂时告一段落，关于它们，更多是要合理并灵活地运用，组合，才能让程序更加健硕。

完结撒花！！！！！！！！