c语言 ，回调函数[个人理解]

回调函数：把需要调用的方法的指针pCallBackFuncX作为参数传递给一个函数UsrFunction，以便该UsrFunction函数在处理相似事件的时候可以灵活的使用不同的方法。

 

以在flash中存储有序的交易记录为例:

交易记录列表内容如下所示，我们要对其排序然后存储到flash当中去。这个排序函数写作： int SortReclist(RECLIST_ST * reclist);

typedef struct {
    char cityCode[] ;            //城市代码 + 应用序列号
    char usrName[];
    unsigned char tradeTime[];      //交易时间【bcd】 年 月 日 时 分 秒
    unsigned char TerminalCode[];   //终端硬件序列号
    unsigned char reserve[];
} RECS_ST ;//交易记录

typedef struct {
    unsigned char count[] ;
    unsigned char max[] ;
    unsigned char data[N_MAX_RECORD][SIZE_OF_RECS];// sizeof(RECS_ST); //要对这里的数据进行排序、去重。
    unsigned char check ;
} RECLIST_ST;//交易记录列表

我们使用冒泡排序的方法对其中的数据进行排序，我们得到一组无序数据，我们不知道这组数据有多少个数据项、一个数据项多大、怎么比较他们的大小、如何交换数据项的位置。

我们可以设计如下，我们需要传入的参数不仅是数据p_data_in、n_elements、element_size，还有方法cmp_func、mem_swap：

        bubble_sort(void* p_data_in ,                  //pointer to data to sort  待排列的数据
                    int n_elements ,                   //number of elements        待排列的数据个数
                    int element_size,                  //size of each element == sizeof(RECS_ST) 数据宽度
                    (CALLBACK_AFC_DATA_CMP) cmp_func , //cmp_func: pointer to comparison function  判定其排列次序的方法，这个是根据需要变换的。
                    (CALLBACK_MEM_SWAP) mem_swap) ;    //mem_swap: pointer to swap function or NULL 内存交换的方法

　　　　typedef void (*CALLBACK_MEM_SWAP)(void *, void *, int n_bytes)  ;
　　　　typedef int (*CALLBACK_AFC_DATA_CMP)(const void *, const void *)  ;

bubble_sort的实现如下：

//ret==1: error
//ret==0: ok
int bubble_sort(void *base ,           //pointer to data to sort
                int n_elements ,   //number of elements
                int size_element ,      //size of each element
                CALLBACK_AFC_DATA_CMP cmp_func ,//cmp_func: pointer to comparison function
                CALLBACK_MEM_SWAP mem_swap )//mem_swap: pointer to swap function or NULL
{
    int i, j, flag , cmp ;
    if( base==0 || cmp_func==0 || mem_swap==0 ){
        return 1 ;
    }

    for (i=0; i<n_elements-1; i++)
    {
        flag = 0;
        for (j=0; j<n_elements-1-i; j++)
        {
            cmp = cmp_func( ((char *)base+size_element*j ) ,  ((char *)base+size_element*(j+1)) )  ;
            if ( cmp > 0 )
            {
                mem_swap( ((char *)base+j*size_element) ,  ((char *)base+(j+1)*size_element)  , size_element );
                flag = 1;
            }
        }
        if ( !flag ) {
            break ;
        }
    }
    return 0;
} 

int SortReclist(RECLIST_ST * reclist)
{
    int ret;
    unsigned char count[]; 

    do{
        memcpy(count , reclist->count , sizeof( count )); //这里是解决mdk对外部全局变量不能正确强转的解决办法，无视

        bubble_sort(reclist->data ,  //pointer to data to sort
                    *(signed short*)count ,   //number of elements
                    sizeof( RECS_ST ) ,  //size of each element
                    (CALLBACK_AFC_DATA_CMP) reclistcmp , //cmp_func: pointer to comparison function
                    (CALLBACK_MEM_SWAP)mem_swap) ; //mem_swap: pointer to swap function or NULL
        //暂且无视排序中去重的需求
    }while(ret!=) ;

    return ;
}  

到底采用何种方式来判断数据的大小，就根据实际需要了。下面是一个实现，只比较城市代码：

int reclistcmp(char *before ,char *next )
{
    int ret ;
    ret = memcmp(before ,next , );  //citycode[2] 简单判定
    return ret ;
} 

好处是，以回调函数的方式，在写主体框架时，可以不用知道某种功能的具体实现，而只是提出这个需求。

【写框架的人并不是完全不关心具体实现，不合理的框架设计导致具体功能无法按照给定的接口来实现。】

这样在处理具体业务时有更高的灵活性，这个功能的具体实现甚至可以交给其他人去完成。

//-----------------------------------------------------------------------------------------------------------------------------------------------//

另外，linux设备驱动函数注册也是回调的思想。linux内核并不知道我们具体设备的操作方式，它是这样对设备进行操作的，先规定操作函数的形式：

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 (*readdir) (struct file *, void *, filldir_t);
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
    int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);//指定函数接口形式
    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 *, struct dentry *, 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 (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
    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 (*dir_notify)(struct file *filp, unsigned long arg);
    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);
};

然后驱动设计者按照规定的形式实现ioctl。

/* 应用程序对设备文件/dev/leds执行ioctl(...)时，
 * 就会调用s3c24xx_leds_ioctl函数
 */
static int s3c24xx_leds_ioctl(
    struct inode *inode,
    struct file *file,
    unsigned int cmd,//ON / OFF
    unsigned long arg)//n_led
    {
    if (arg > ) {
        return -EINVAL;
    }

    switch(cmd) {
    case IOCTL_LED_ON:
        // 设置指定引脚的输出电平为0
        s3c2410_gpio_setpin(led_table[arg], );
        return ;

    case IOCTL_LED_OFF:
        // 设置指定引脚的输出电平为1
        s3c2410_gpio_setpin(led_table[arg], );
        return ;

    default:
        return -EINVAL;
    }
}

驱动设计者再注册操作集，包括了ioctl。

static struct file_operations s3c24xx_leds_fops = {
    .owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open   =   s3c24xx_leds_open,
    .ioctl  =   s3c24xx_leds_ioctl,
};

//in moudle_init:
ret = register_chrdev(LED_MAJOR, DEVICE_NAME, &s3c24xx_leds_fops);

这样，在打开操作设备时，系统使用到了驱动设计者的设备操作方法。

扩展阅读：

1.回调机制

　　http://blog.sina.cn/dpool/blog/s/blog_77c632410101cjty.html

2.简单的c++回调函数设计方法(一)

　　回调实现分层设计。

　　http://blog.chinaunix.net/uid-21222282-id-1829257.html