2）  分步解析

有的C语言基础不是很好的朋友，可能无法一眼看出来这个定义，为了让新手更容易看懂，我们来看一下下面一个递进式的定义：

int fun；

这是一个整型变量fun；

int fun（）；

这是一个函数fun，参数    ：空返回值：int型

int fun（struct touch＿message ＊）；

这是一个函数fun，参数    ：struct touch＿message ＊的一个指针返回值：int型

上述的变化都好理解，下面我们将fun做如下修改：

int （＊fun）（struct touch＿message ＊）；

括号的优先级最高，（fun）一旦如此定义，那么fun就要先和结合，所以fun变成了一个指针，

那么该指针指向什么呢？就需要看外面是如何定义的，右边是（struct touch＿message ＊ ），左边是int，所以说明指针指向的是一个函数，

参数    ：struct touch＿message ＊的一个指针返回值：int型

举例：将函数my＿fun赋值给函数指针fun。int my＿fun（struct touch＿message ＊）｛｝int （＊fun）（struct touch＿message ＊）；fun ＝ my＿fun；

这里有一个隐藏的知识点，函数名其实也是一个地址，而且赋值的时候函数类型必须和函数指针类型一致。

typedef int （＊fun）（struct touch＿message ＊）；

如果左边再加上typedef呢？相当于是设置fun为新的类型，我们可以用fun来定义一个函数指针，该函数类型同上。

举例用新的类型定义一个函数指针变量，并给他赋值。typedef int （＊fun）（struct touch＿message ＊）；int my＿fun（struct touch＿message ＊）｛｝fun fun＿ptr；fun＿ptr ＝ my＿fun；

然后将参数修改为，touch＿message＿t，就得到了粉丝的源码中的样子，

typedef int （＊fun）（touch＿message＿t）；

但是粉丝的源码中定义的函数类型缺少了对函数返回值的描述，所以左侧增加一个int或者其他类型即可即可。

3． 函数指针

函数指针在linux内核中使用非常频繁，

比如字符设备，内核给多有的字符设备提供了一个统一的接口，我们对设备的所有操作被抽象成read、write、open、close等，并封装到结构体struct 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 （＊aio＿read） （struct kiocb ＊， const struct iovec ＊， unsigned long， loff＿t）；
ssize＿t （＊aio＿write） （struct kiocb ＊， const struct iovec ＊， unsigned long， loff＿t）；
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 （＊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 ＊＊）；
long （＊fallocate）（struct file ＊file， int mode， loff＿t offset，
    loff＿t len）；
int （＊show＿fdinfo）（struct seq＿file ＊m， struct file ＊f）；
｝；

那么我们应该如何定义该结构体变量并初始化呢？

static struct file＿operations hello＿ops ＝
｛
．open ＝ hello＿open，
．release ＝ hello＿release，
．read ＝ hello＿read，
．write ＝ hello＿write，
｝；

函数定义如下：

static int hello＿open （struct inode ＊inode， struct file ＊filep）
｛
return 0；
｝
static int hello＿release （struct inode ＊inode， struct file ＊filep）
｛
return 0；
｝
static ssize＿t hello＿read （struct file ＊filep， char ＿＿user ＊buf， size＿t size， loff＿t ＊pos）
｛
return size；
｝
static ssize＿t hello＿write （struct file ＊filep， const char ＿＿user ＊buf， size＿t size， loff＿t ＊pos）
｛
return size；
｝

注意，函数的参数和返回值，必须严格按照结构体struct file＿operations中的类型定义。