回调函数分层编码（基于C语言）

前言：这个回调实例分三层：底层为任务函数实现层；核心层为数据结构和任务注册/注销层；上层为应用层。

底层：

/task_def.c/
#include <stdio.h>

void
task1(int x, char y, void * ptr)
{
    printf("task1:argv[0] = %d argv[1] = %c argv[2] = %s\n", x, y, (char *)ptr);
}


void
task2(int x, char y, void * ptr)
{
    printf("task1:argv[0] = %d argv[1] = %c argv[2] = %s\n", x, y, (char *)ptr);
}

void
task3(int x, char y, void * ptr)
{
    printf("task1:argv[0] = %d argv[1] = %c argv[2] = %s\n", x, y, (char *)ptr);
}


/task_def.h/
#ifndef __TASK_DEF_H__
#define __TASK_DEF_H__

typedef void (*PF)(int x, char y, void *ptr);

void
task1(int x, char y, void * ptr);
void
task2(int x, char y, void * ptr);
void
task3(int x, char y, void * ptr);

#endif

 

 

核心层：

core.c
#include <stdio.h>
#include "task_def.h"
#include "core.h"


PF gloabl_tasks[MAX_TASKS];

void
task_stack_init(void)
{
    for(int i = 0; i < MAX_TASKS; ++i){
        gloabl_tasks[i] = NULL;
    }
}

int
register_task(PF task)
{
    int post;
    for(post = 0; post < MAX_TASKS; ++post){
        if( gloabl_tasks[post] == NULL )
            break;
    }
    gloabl_tasks[post] = task;
    printf("register the task is normal[post = %d]\n", post);

    return post;
}

void  
unregister_task(int task_post)
{
    if( (task_post < MAX_TASKS) && (task_post >=0) ){
        gloabl_tasks[task_post] = NULL;
        printf("unregister the task is normal[post = %d]\n", task_post);
    }
}

core.h
#ifndef __CORE_H__
#define __CORE_H__

#define MAX_TASKS 10

extern PF gloabl_tasks[MAX_TASKS];

void
task_stack_init(void);
int
register_task(PF task);
void  
unregister_task(int task_post);

#if 0
typedef struct task_args = {
    int x;
    char y;
    void ptr;
}task_args_t;
#endif

#endif

应用层：

#include <stdio.h>
#include "task_def.h"
#include "core.h"

int 
main(int argc, char *argv[])
{
    int i = 0, ret = 0;

    task_stack_init();
    ret = register_task(task1);

    for( ;i < (ret+1); ++i){
        gloabl_tasks[i](1, 'a', NULL);
    }

    unregister_task(ret);
    
    return 0;
}