什么是表驱动

普通代码

----------------------------------------------------------------------------------------------------------------------------

void msg_proc(const char *msg_type, const char *msg_buf)

{

if (0 == strcmp(msg_type, "inivite"))

{

inivite_fun(msg_buf);

}

else if (0 == strcmp(msg_type, "tring_100"))

{

tring_fun(msg_buf);

}

else if (0 == strcmp(msg_type, "ring_180"))

{

ring_180_fun(msg_buf);

}

else if (0 == strcmp(msg_type, "ring_181"))

{

ring_181_fun(msg_buf);

}

else if (0 == strcmp(msg_type, "ring_182"))

{

ring_182_fun(msg_buf);

}

else if (0 == strcmp(msg_type, "ring_183"))

{

ring_183_fun(msg_buf);

}

else if (0 == strcmp(msg_type, "ok_200"))

{

ok_200_fun(msg_buf);

}

。。。。。。

else if (0 == strcmp(msg_type, "fail_486"))

{

fail_486_fun(msg_buf);

}

else

{

log("未识别的消息类型%s\n", msg_type);

}

}

----------------------------------------------------------------------------------------------------------------------------

使用表驱动改进后的代码

----------------------------------------------------------------------------------------------------------------------------

typedef void (*SIP_MSG_FUN)(const char *);

typedef struct __msg_fun_st

{

const char *msg_type;//消息类型

SIP_MSG_FUN fun_ptr;//函数指针

}msg_fun_st;

msg_fun_st msg_flow[] =

{

{"inivite", inivite_fun},

{"tring_100", tring_fun},

{"ring_180", ring_180_fun},

{"ring_181", ring_181_fun},

{"ring_182", ring_182_fun},

{"ring_183", ring_183_fun},

{"ok_200", ok_200_fun},

。。。。。。

{"fail_486", fail_486_fun}

};

void msg_proc(const char *msg_type, const char *msg_buf)

{

int type_num = sizeof(msg_flow) / sizeof(msg_fun_st);

int i = 0;

for (i = 0; i < type_num; i++)

{

if (0 == strcmp(msg_flow[i].msg_type, msg_type))

{

msg_flow[i].fun_ptr(msg_buf);

return ;

}

}

log("未识别的消息类型%s\n", msg_type);

}

----------------------------------------------------------------------------------------------------------------------------

为什么使用表驱动

有什么问题？什么感觉？

可读性不高：找一个消息的处理部分代码需要跳转多层代码。

程序缺少主心骨：缺少一个能够提纲挈领的主干，程序的主干被淹没在大量的代码逻辑之中。

使用表驱动的代码(复杂例子)

----------------------------------------------------------------------------------------------------------------------------

typedef struct __EVENT_DRIVE

{

MODE_TYPE mod;//消息的发送模块

EVENT_TYPE event;//消息类型

STATUS_TYPE status;//自身状态

EVENT_FUN eventfun;//此状态下的处理函数指针

}EVENT_DRIVE;

EVENT_DRIVE eventdriver[] = //这就是一张表的定义，不一定是数据库中的表。也可以使自己定义的一个结构体数组。

{

{MODE_A, EVENT_a, STATUS_1, fun1}

{MODE_A, EVENT_a, STATUS_2, fun2}

{MODE_A, EVENT_a, STATUS_3, fun3}

{MODE_A, EVENT_b, STATUS_1, fun4}

{MODE_A, EVENT_b, STATUS_2, fun5}

{MODE_B, EVENT_a, STATUS_1, fun6}

{MODE_B, EVENT_a, STATUS_2, fun7}

{MODE_B, EVENT_a, STATUS_3, fun8}

{MODE_B, EVENT_b, STATUS_1, fun9}

{MODE_B, EVENT_b, STATUS_2, fun10}

};

int driversize = sizeof(eventdriver) / sizeof(EVENT_DRIVE)//驱动表的大小

EVENT_FUN GetFunFromDriver(MODE_TYPE mod, EVENT_TYPE event, STATUS_TYPE status)//驱动表查找函数

{

int i = 0;

for (i = 0; i < driversize; i ++)

{

if ((eventdriver[i].mod == mod) && (eventdriver[i].event == event) && (eventdriver[i].status == status))

{

return eventdriver[i].eventfun;

}

}

return NULL;

}

----------------------------------------------------------------------------------------------------------------------------

如果性能要求很高，可以进行适当的优化。比如，可以建立一个多维数组，每一维分别表示模块，状态，消息。这样，就可以根据这三者的枚举直接根据下标定位到处理函数，而不是查表。（其实还是数据驱动的思想：数据结构是静态的算法。）

----------------------------------------------------------------------------------------------------------------------------

现在呢？

除去重复代码，提高了程序的可读性。一个消息如何处理，只要看一下驱动表就知道，非常明显。

隔离变化: 每个消息处理的逻辑是不变的，但是消息可能是变化的，那就把容易变化的消息和不容易变化的逻辑分离。

/article/2031638.html(什么是数据驱动编程)

/article/2031667.html(数据驱动编程之表驱动法)
http://blog.csai.cn/user1/265/archives/2005/1790.html(基于表驱动（table-driven）技术所实现的异常处理（EH）的几个不足之处))