数据压倒一切。如果选择了正确的数据结构并把一切组织的井井有条，正确的算法就不言自明。编程的核心是数据结构，而不是算法。

——Rob Pike
, ^' F+ E9 t3 j3 Y6 Q7 p1 {4 b4 K
) {0 B2 d+ `9 v& w9 ]4 H说明

本文基于这样的认识：数据是易变的，逻辑是稳定的。

本文例举的编程实现多为代码片段，但不影响描述的完整性。本文例举的编程虽然基于C语言，但其编程思想也适用于其他语言。此外，本文不涉及语言相关的运行效率讨论。

1 概念提出

所谓表驱动法(Table-DrivenApproach)简而言之就是用查表的方法获取数据。此处的“表”通常为数组，但可视为数据库的一种体现。

根据字典中的部首检字表查找读音未知的汉字就是典型的表驱动法，即以每个字的字形为依据，计算出一个索引值，并映射到对应的页数。相比一页一页地顺序翻字典查字，部首检字法效率极高。具体到编程方面，在数据不多时可用逻辑判断语句(if…else或switch…case)来获取值；但随着数据的增多，逻辑语句会越来越长，此时表驱动法的优势就开始显现。例如，用36进制(A表示10，B表示11，…)表示更大的数字，逻辑判断语句如下：
if(ucNum < 10)
{
0 M: q& V9 r5 c) A. T, i    ucNumChar = ConvertToChar(ucNum);
  o1 m4 `* r/ B5 l* q& ?" b3 X}
else if(ucNum == 10)
& U. y  [9 B$ W& x- `/ _2 h0 D7 b4 u{
1 ^* Z4 C8 ~: E4 e7 a( [. B& B    ucNumChar = 'A';
9 B& O  f1 }+ A. B. f; \}
else if(ucNum == 11)
{
    ucNumChar = 'B';
; }! b) J. S# Z: m: V* g}
else if(ucNum == 12)
# H- a8 Z+ w$ p6 Z  N+ A+ a0 i{
    ucNumChar = 'C';
6 Y9 s' A0 U5 l* _0 X# e0 v}
//... ...
1 |9 c. b; D) N. g) zelse if(ucNum == 35)
{
    ucNumChar = 'Z';
# Y2 b" D1 a3 X}


$ q, N, A& R" b当然也可以用switch…case结构，但实现都很冗长。而用表驱动法(将numChar存入数组)则非常直观和简洁。如：
) F, F6 z* `7 F! l8 jCHAR aNumChars[] = {'0', '1', '2', /*3~9*/'A', 'B', 'C', /*D~Y*/'Z'};
" E  T. L6 V: N7 D% x6 NCHAR ucNumChar = aNumChars[ucNum % sizeof(aNumChars)];
9 i; G! Z: m& b% u; l9 d8 S
2 J, T0 m$ W+ W" s- K
2 i* d. M1 l, K; B- G: @像这样直接将变量当作下数组下标来读取数值的方法就是直接查表法。注意，如果熟悉字符串操作，则上述写法可以更简洁：
CHAR ucNumChar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[ucNum];
6 A' R9 ?) J$ ?
5 \, V6 {; W) @1 ~+ e$ `
使用表驱动法时需要关注两个问题：一是如何查表，从表中读取正确的数据；二是表里存放什么，如数值或函数指针。前者参见1.1节“查表方式”内容，后者参见1.2节“实战示例”内容。
5 i% O! W5 P& v3 n. N: E4 l1 d
" C( o. W; v2 |1.1查表方式
# S" P8 U0 N; e7 x

常用的查表方式有直接查找、索引查找和分段查找等。

1 |; t+ K' s3 g' U1 V! S1.1.1直接查找
& g9 R5 I" j  Y4 ^

即直接通过数组下标获取到数据。如果熟悉哈希表的话，可以很容易看出这种查表方式就是哈希表的直接访问法。

如获取星期名称，逻辑判断语句如下：
; E7 B  d7 g% b5 O( L- u& U1 Sif(0 == ucDay)
. j: j" `0 }2 W& \( m' H( _{
4 r# r' C$ p7 Y! ]3 B2 D, D    pszDayName = "Sunday";
}
; W) x" k( M! J" x" w' L. Lelse if(1 == ucDay)
9 X0 `" ~4 V$ G4 M+ _{
    pszDayName = "Monday";
4 E4 I+ @6 ?6 C}
8 i2 e% Y+ L" z  M! Q4 t//... ...
% Q: s, Q6 O5 n$ F" L$ M. ^else if(6 == ucDay)
{
1 H/ {- e2 {4 b- N    pszDayName = "Saturday";
}


而实现同样的功能，可将这些数据存储到一个表里：
! x4 S! b7 E$ F* v+ h6 b! RCHAR *paNumChars[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday",  "Saturday"};
6 R; w+ p6 Z) e+ b: J5 x4 I& OCHAR *pszDayName = paNumChars[ucDay];


- V- O7 s/ n$ ~; c类似哈希表特性，表驱动法适用于无需有序遍历数据，且数据量大小可提前预测的情况。对于过于复杂和庞大的判断，可将数据存为文件，需要时加载文件初始化数组，从而在不修改程序的情况下调整里面的数值。有时，访问之前需要先进行一次键值转换。如表驱动法表示端口忙闲时，需将槽位端口号映射为全局编号。所生成的端口数目大小的数组，其下标对应全局端口编号，元素值表示相应端口的忙闲状态。
. }" }! J: h" L/ X; e" a1 {
: j' I1 v( _# Y9 m; M1 r3 w1.1.2索引查找

有时通过一次键值转换，依然无法把数据(如英文单词等)转为键值。此时可将转换的对应关系写到一个索引表里，即索引访问。

如现有100件商品，4位编号，范围从0000到9999。此时只需要申请一个长度为100的数组，且对应2位键值。但将4位的编号转换为2位的键值，可能过于复杂或没有规律，最合适的方法是建立一个保存该转换关系的索引表。采用索引访问既节省内存，又方便维护。比如索引A表示通过名称访问，索引B表示通过编号访问。

7 I! g  s1 p8 d. e2 p9 H1.1.3分段查找
0 n7 e2 }0 b" |- Y- e9 @

通过确定数据所处的范围确定分类(下标)。有的数据可分成若干区间，即具有阶梯性，如分数等级。此时可将每个区间的上限(或下限)存到一个表中，将对应的值存到另一表中，通过第一个表确定所处的区段，再由区段下标在第二个表里读取相应数值。注意要留意端点，可用二分法查找，另外可考虑通过索引方法来代替。

如根据分数查绩效等级：
( x3 x4 l. M8 U  B#define MAX_GRADE_LEVEL   (INT8U)5
DOUBLE aRangeLimit[MAX_GRADE_LEVEL] = {50.0, 60.0, 70.0, 80.0, 100.0};
) h% T1 f) o; }* p  W% gCHAR *paGrades[MAX_GRADE_LEVEL] = {"Fail", "Pass", "Credit", "Distinction", "High Distinction"};
  }; t3 j) R2 z4 ?
! z% P9 D# `  M0 `  o$ n! K7 hstatic CHAR* EvaluateGrade(DOUBLE dScore)
{
    INT8U ucLevel = 0;
6 K8 k) M' P! y- e* Z$ H4 s    for(; ucLevel < MAX_GRADE_LEVEL; ucLevel++)
  f% }9 l; q" p# R2 f* X    {
        if(dScore < aRangeLimit[ucLevel])
0 s7 x* |: D9 Y" Y# ^6 X( U            return paGrades[ucLevel];
4 q( g7 H7 U, H! h    }
; Q+ ]# O& A& k4 O    return paGrades[0];
% q4 b9 r' A( B0 b! T1 z}
0 P- w# k- h5 ~5 Y
8 G" T) F! q9 E/ A6 u- U
上述两张表(数组)也可合并为一张表(结构体数组)，如下所示：
" ^: I! b4 |# {, ]7 G8 s, i" Utypedef struct{
. i! _: u5 f; m5 E    DOUBLE  aRangeLimit;
    CHAR    *pszGrade;
7 [6 R. c8 Q2 d+ c! v+ N1 ^}T_GRADE_MAP;
( m* r0 X5 z- h% g7 ?' e1 g6 M
T_GRADE_MAP gGradeMap[MAX_GRADE_LEVEL] = {
    {50.0,              "Fail"},
    {60.0,              "Pass"},
' k! X7 D& Z4 V% g4 E    {70.0,              "Credit"},
9 l4 X9 t* p$ z% O8 Q# y    {80.0,              "Distinction"},
- R% x% V, c$ z: p6 G! K    {100.0,             "High Distinction"}
3 M% q6 T9 X  Y5 Z! \- ~+ Z) i. U};

1 M; r4 U* P  @+ T: F4 rstatic CHAR* EvaluateGrade(DOUBLE dScore)
( L" ^1 e8 _% C4 k' Y4 j& g{
- u6 F& M- K# {    INT8U ucLevel = 0;
    for(; ucLevel < MAX_GRADE_LEVEL; ucLevel++)
6 Q+ S1 e7 e2 f9 v0 o- H6 x    {
        if(dScore < gGradeMap[ucLevel].aRangeLimit)
            return gGradeMap[ucLevel].pszGrade;
4 b& r7 _, b6 T! W8 c    }
4 E; E' g& j2 x! J. O    return gGradeMap[0].pszGrade;
, x1 O# h5 y2 u2 T3 W( }! ]" Q/ D}
' ]) N: J1 A+ N* M+ v0 U

" _' M3 R5 G( K% H5 s: @8 M; J. }该表结构已具备的数据库的雏形，并可扩展支持更为复杂的数据。其查表方式通常为索引查找，偶尔也为分段查找；当索引具有规律性(如连续整数)时，退化为直接查找。使用分段查找法时应注意边界，将每一分段范围的上界值都考虑在内。找出所有不在最高一级范围内的值，然后把剩下的值全部归入最高一级中。有时需要人为地为最高一级范围添加一个上界。同时应小心不要错误地用“<”来代替“<=”。要保证循环在找出属于最高一级范围内的值后恰当地结束，同时也要保证恰当处理范围边界。

1.2实战示例

本节多数示例取自实际项目。表形式为一维数组、二维数组和结构体数组；表内容有数据、字符串和函数指针。基于表驱动的思想，表形式和表内容可衍生出丰富的组合。

. h5 F9 U& R) f6 ~6 }2 Y% ?/ A1.2.1字符统计
7 s+ Z% \0 I+ ]  A9 O1 G" ?/ y

问题：统计用户输入的一串数字中每个数字出现的次数。

普通解法主体代码如下：
INT32U aDigitCharNum[10] = {0}; /* 输入字符串中各数字字符出现的次数 */
0 Z( Y  j' |8 J% D% hINT32U dwStrLen = strlen(szDigits);
' j$ C1 P" z! `: E- Y$ _
/ G; w0 X& V, o: _9 i8 t9 z0 qINT32U dwStrIdx = 0;
" q: F, s; ?  p! sfor(; dwStrIdx < dwStrLen; dwStrIdx++)
/ w( x1 d+ T" k( k( ~- _7 k1 ~4 D{
    switch(szDigits[dwStrIdx])
3 B% |1 o* U5 Y8 A    {
9 M) `: d  F9 X- f$ ]        case '1':
            aDigitCharNum[0]++;
            break;
6 ~+ ^0 G: C, y) o$ |1 X' p; B        case '2':
3 J+ Q8 r" T: q( }8 j            aDigitCharNum[1]++;
            break;
, y9 Y' c, ~$ m, L( e( c        //... ...
  u& k* ^! k/ K" s: Q: |+ [2 L        case '9':
            aDigitCharNum[8]++;
            break;
+ J* @6 L* b. @5 V9 @$ v% `4 _    }
( |# M8 V' n; E}


4 H8 `  B1 V% v, B$ k# U% i' y这种解法的缺点显而易见，既不美观也不灵活。其问题关键在于未将数字字符与数组aDigitCharNum下标直接关联起来。以下示出更简洁的实现方式：
for(; dwStrIdx < dwStrLen; dwStrIdx++)
* c" o+ u4 O; c8 ?{
+ N, C, P) e% l& d$ e" t- i8 ^  N    aDigitCharNum[szDigits[dwStrIdx] - '0']++;
}

5 a8 P, k" m0 l4 I5 g0 S  P- n
" c% N' g7 E* f2 Q# P2 I% A上述实现考虑到0也为数字字符。该解法也可扩展至统计所有ASCII可见字符。

1.2.2月天校验
# ^5 W* C# V5 M) ]& T- z3 [) P- N

问题：对给定年份和月份的天数进行校验(需区分平年和闰年)。

普通解法主体代码如下：
switch(OnuTime.Month)
: P: x( t0 y* m7 P/ X- D{
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
+ P/ u3 W' }  U1 x$ W; Z    case 10:
    case 12:
( D$ M  {& h8 C, j. f, H9 V        if(OnuTime.Day>31 || OnuTime.Day<1)
! c1 L& r9 n' T# s( t2 n- P5 h# a        {
! U" {- ^- d/ A  P            CtcOamLog(FUNCTION_Pon,"Don't support this Day: %d(1~31)!!!\n", OnuTime.Day);
            retcode = S_ERROR;
        }
        break;
    case 2:
' Y: X" ^$ q3 t) o8 Z        if(((OnuTime.Year%4 == 0) && (OnuTime.Year%100 != 0)) || (OnuTime.Year%400 == 0))
        {
            if(OnuTime.Day>29 || OnuTime.Day<1)
            {
                CtcOamLog(FUNCTION_Pon,"Don't support this Day: %d(1~29)!!!\n", OnuTime.Day);
                retcode = S_ERROR;
            }
) X6 {8 E+ c/ t4 E! M1 M% e' y        }
        else
        {
( Q4 V/ o4 g1 i# R& k            if(OnuTime.Day>28 || OnuTime.Day<1)
3 D. ~8 _! e4 z& C/ K) f9 r            {
8 H8 t, u3 a/ }; G8 ?6 ~                CtcOamLog(FUNCTION_Pon,"Don't support this Day: %d(1~28)!!!\n", OnuTime.Day);
; `- B) R) G0 }3 g9 V3 S5 s                retcode = S_ERROR;
            }
1 E' Z# [' L2 H) w* o) V        }
2 w' I  D* b) r. ^; y2 S        break;
    case 4:
% U% c% }7 x" y2 ^- H9 p: k    case 6:
    case 9:
    case 11:
        if(OnuTime.Day>30 || OnuTime.Day<1)
        {
4 [* ~: f% A2 A            CtcOamLog(FUNCTION_Pon,"Don't support this Day: %d(1~30)!!!\n", OnuTime.Day);
/ g( }8 I; @9 E  I. C3 |) ^! v            retcode = S_ERROR;
) }4 P6 k  ?4 C, @& T        }
# W3 X* r1 C- o        break;
    default:
        CtcOamLog(FUNCTION_Pon,"Don't support this Month: %d(1~12)!!!\n", OnuTime.Month);
        retcode = S_ERROR;
4 E7 t& z/ U6 |, z" _        break;
}
9 Q( k' K" G) P$ W

2 X3 x1 f6 a+ B. Y以下示出更简洁的实现方式：
. M6 I1 m; \* L# f7 Z#define MONTH_OF_YEAR 12    /* 一年中的月份数 */
" m6 B# L/ Q: k: D
/* 闰年：能被4整除且不能被100整除，或能被400整除 */
#define IS_LEAP_YEAR(year) ((((year) % 4 == 0) && ((year) % 100 != 0)) || ((year) % 400 == 0))
9 P' l+ y, f/ E; k2 |5 X" k
/* 平年中的各月天数，下标对应月份 */
INT8U aDayOfCommonMonth[MONTH_OF_YEAR] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
2 U4 {1 p! G3 j- s; T5 x" I  m
3 p$ u# [+ e9 Q; E/ ^2 dINT8U ucMaxDay = 0;
if((OnuTime.Month == 2) && (IS_LEAP_YEAR(OnuTime.Year)))
    ucMaxDay = aDayOfCommonMonth[1] + 1;
& A' n3 }) c% o& ~7 delse
    ucMaxDay = aDayOfCommonMonth[OnuTime.Month-1];
3 q) m) b5 b' y+ C" k  G: o" ^* _
if((OnuTime.Day < 1) || (OnuTime.Day > ucMaxDay)
{
    CtcOamLog(FUNCTION_Pon,"Month %d doesn't have this Day: %d(1~%d)!!!\n",
              OnuTime.Month, OnuTime.Day, ucMaxDay);
) e3 l, J. n4 z0 S! f  `5 b- v    retcode = S_ERROR;
7 n9 k/ \2 h# I+ b! g  Q}


1.2.3名称构造
8 @# N1 V7 b( a& E' s( \

问题：根据WAN接口承载的业务类型(Bitmap)构造业务类型名称字符串。

普通解法主体代码如下：
void Sub_SetServerType(INT8U *ServerType, INT16U wan_servertype)
{
5 H% h/ i3 Z  A' \' {$ c) X/ K    if ((wan_servertype & 0x0001) == 0x0001)
0 `& o  n) M& N7 `3 N+ g! d    {
# Y9 z5 U. n  }* a+ i; {        strcat(ServerType, "_INTERNET");
    }
/ l! b  p. \8 Q) {; y    if ((wan_servertype & 0x0002) == 0x0002)
    {
        strcat(ServerType, "_TR069");
    }
8 v: H8 _5 i6 f" _- g% A1 `    if ((wan_servertype & 0x0004) == 0x0004)
    {
        strcat(ServerType, "_VOIP");
    }
: o3 U( {' q% Z3 ]) h+ ?# P7 `( w    if ((wan_servertype & 0x0008) == 0x0008)
    {
  [" c+ d. n# K/ g4 ?. I0 v        strcat(ServerType, "_OTHER");
# Q6 _" H1 z) |4 s! ]    }
# L- \9 j  s1 c2 v; d  D$ U' s* v. B& Q}
* d* C: ~8 w: Q1 B2 U


以下示出C语言中更简洁的实现方式：
( L5 [, T) \) a0 j' v/* 获取var变量第bit位，编号从右至左 */
#define  GET_BIT(var, bit)   (((var) >> (bit)) & 0x1)
8 G' `  S2 U4 m. g" bconst CHAR* paSvrNames[] = {"_INTERNET", "_TR069", "_VOIP", "_OTHER"};
const INT8U ucSvrNameNum = sizeof(paSvrNames) / sizeof(paSvrNames[0]);

, N; K9 y; h0 H! y+ D  S" VVOID SetServerType(CHAR *pszSvrType, INT16U wSvrType)
{
    INT8U ucIdx = 0;
    for(; ucIdx < ucSvrNameNum; ucIdx++)
    {
        if(1 == GET_BIT(wSvrType, ucIdx))
  x& N* e5 b% ?9 U8 i6 ^! e6 [            strcat(pszSvrType, paSvrNames[ucIdx]);
8 r7 E: S+ q4 m& \) R* E# a1 u    }
1 Q8 L* [- t/ c% p) f( f# n2 F9 w/ f}
1 Q. r3 q0 U3 z  `1 Q$ C9 v
* B' j" H( |* |, t  y3 w& Q
7 S! q2 P9 O' P4 V* K新的实现将数据和逻辑分离，维护起来非常方便。只要逻辑(规则)不变，则唯一可能的改动就是数据(paSvrNames)。
9 U7 X+ i2 O4 w2 W( L
1.2.4值名解析

问题：根据枚举变量取值输出其对应的字符串，如PORT_FE(1)输出“Fe”。

//值名映射表结构体定义，用于数值解析器
typedef struct{
    INT32U dwElem;    //待解析数值，通常为枚举变量
3 `. P" r- _. t& M6 [    CHAR*  pszName;   //指向数值所对应解析名字符串的指针
}T_NAME_PARSER;

/******************************************************************************
* 函数名称:  NameParser
8 c5 v/ c1 E; y" P' f* 功能说明:  数值解析器，将给定数值转换为对应的具名字符串
+ r  f) e% h; Y3 H% s* 输入参数:  VOID *pvMap       :值名映射表数组，含T_NAME_PARSER结构体类型元素
                                VOID指针允许用户在保持成员数目和类型不变的前提下，
                                定制更有意义的结构体名和/或成员名。
/ f, l/ q0 d2 {  T% y! u             INT32U dwEntryNum :值名映射表数组条目数
             INT32U dwElem     :待解析数值，通常为枚举变量
             INT8U* pszDefName :缺省具名字符串指针，可为空
* 输出参数:  NA
+ I6 W+ }2 w8 G- \. m7 m2 \* 返回值  :  INT8U *: 数值所对应的具名字符串
             当无法解析给定数值时，若pszDefName为空，则返回数值对应的16进制格式
- ~+ Y, y0 r, `0 Q6 P             字符串；否则返回pszDefName。
( X' ?7 ~; \8 r4 _5 P******************************************************************************/
INT8U *NameParser(VOID *pvMap, INT32U dwEntryNum, INT32U dwElem, INT8U* pszDefName)
; s) P& B" h8 ~- r{
, r  _4 |  ?& Y+ [1 h. Y    CHECK_SINGLE_POINTER(pvMap, "NullPoniter");
- H6 q8 T; l" |1 \+ I
( u& g0 i. y& j  e& P+ A! ~    INT32U dwEntryIdx = 0;
" T$ }  b8 c1 G2 I+ M' `* c    for(dwEntryIdx = 0; dwEntryIdx < dwEntryNum; dwEntryIdx++)
    {
) o1 U  e- T, n; j/ x# b        T_NAME_PARSER *ptNameParser = (T_NAME_PARSER *)pvMap;
" C4 g- i0 f; \' C7 s        if(dwElem == ptNameParser->dwElem)
        {
1 F: Q( j; h, A4 M5 v4 i            return ptNameParser->pszName;
        }
/ `2 T/ i2 R! k! t3 N! f* x6 {/ t        //ANSI标准禁止对void指针进行算法操作；GNU标准则指定void*算法操作与char*一致。
; J+ u& K$ G+ P: A$ M: t# z        //若考虑移植性，可将pvMap类型改为INT8U*，或定义INT8U*局部变量指向pvMap。
9 k4 J  s9 C' _8 F5 L, d1 D        pvMap += sizeof(T_NAME_PARSER);
    }

    if(NULL != pszDefName)
    {
        return pszDefName;
    }
    else
6 Q4 G- {8 c. |0 K2 J6 x    {
        static INT8U szName[12] = {0}; //Max:"0xFFFFFFFF"
2 X2 E5 Y. b- R4 L& \: _2 n        sprintf(szName, "0x%X", dwElem);
/ u# \& D  }' r6 k% |        return szName;
+ y6 v) V* C1 Q6 Y- R8 @! S    }
}
) u( D. q/ B" f1 |# B
% ~2 q* ~8 p" s% t
% `( W' \/ |* ]: @, x3 Y# }- I; J以下给出NameParser的简单应用示例：
* Y. W4 f9 B  N1 M, d4 R' K//UNI端口类型值名映射表结构体定义
0 Y, k9 v2 \/ b" _typedef struct{
    INT32U dwPortType;
: ?0 M3 f8 n3 S    INT8U* pszPortName;
/ @0 w* R1 Y  k) `: w; `: g$ b: K3 o/ [}T_PORT_NAME;
( Z1 y2 E! x9 H. k//UNI端口类型解析器
T_PORT_NAME gUniNameMap[] = {
) g2 b0 a' b6 r; @    {1,      "Fe"},
    {3,      "Pots"},
/ ]% M  X# {6 i4 d0 [    {99,     "Vuni"}
};
; e; t( }" s, zconst INT32U UNI_NAM_MAP_NUM = (INT32U)(sizeof(gUniNameMap)/sizeof(T_PORT_NAME));
5 B" Z$ f, u  J- |VOID NameParserTest(VOID)
{
, y% f) W1 R$ f7 T# |. U. D    INT8U ucTestIndex = 1;
5 O& H4 W. ], ?1 A7 y
    printf("[%s]<Test Case %u> Result: %s!\n", __FUNCTION__, ucTestIndex++,
9 u( D- r! n. H1 p2 W           strcmp("Unknown", NameParser(gUniNameMap, UNI_NAM_MAP_NUM, 0, "Unknown")) ? "ERROR" : "OK");
    printf("[%s]<Test Case %u> Result: %s!\n", __FUNCTION__, ucTestIndex++,
           strcmp("DefName", NameParser(gUniNameMap, UNI_NAM_MAP_NUM, 0, "DefName")) ? "ERROR" : "OK");
    printf("[%s]<Test Case %u> Result: %s!\n", __FUNCTION__, ucTestIndex++,
: i$ b) B$ `# z: ?           strcmp("Fe", NameParser(gUniNameMap, UNI_NAM_MAP_NUM, 1, "Unknown")) ? "ERROR" : "OK");
' ?2 E. v" s' I1 q) W' @7 a" Z9 p: |5 p    printf("[%s]<Test Case %u> Result: %s!\n", __FUNCTION__, ucTestIndex++,
6 @$ s8 U0 B# _/ G! B% b. U           strcmp("Pots", NameParser(gUniNameMap, UNI_NAM_MAP_NUM, 3, "Unknown")) ? "ERROR" : "OK");
    printf("[%s]<Test Case %u> Result: %s!\n", __FUNCTION__, ucTestIndex++,
+ D7 x5 e9 ~% O8 T7 e6 [0 U           strcmp("Vuni", NameParser(gUniNameMap, UNI_NAM_MAP_NUM, 99, NULL)) ? "ERROR" : "OK");
/ E! Z* \$ l) r) s    printf("[%s]<Test Case %u> Result: %s!\n", __FUNCTION__, ucTestIndex++,
           strcmp("Unknown", NameParser(gUniNameMap, UNI_NAM_MAP_NUM, 255, "Unknown")) ? "ERROR" : "OK");
* f7 U4 I" V* U% m& d! G+ b! d    printf("[%s]<Test Case %u> Result: %s!\n", __FUNCTION__, ucTestIndex++,
2 e# L& ?! v3 I- p+ e3 V$ F, ?           strcmp("0xABCD", NameParser(gUniNameMap, UNI_NAM_MAP_NUM, 0xABCD, NULL)) ? "ERROR" : "OK");
    printf("[%s]<Test Case %u> Result: %s!\n", __FUNCTION__, ucTestIndex++,
, A- z' l/ X; O% C* V+ K           strcmp("NullPoniter", NameParser(NULL, UNI_NAM_MAP_NUM, 0xABCD, NULL)) ? "ERROR" : "OK");
}
9 B7 @2 L+ K/ z+ \4 D

gUniNameMap在实际项目中有十余个条目，若采用逻辑链实现将非常冗长。
0 e7 _* R9 Q3 w- c; j) u
1.2.5取值映射
) J/ ?8 r1 g: d0 S% V

问题：不同模块间同一参数枚举值取值可能有所差异，需要适配。

此处不再给出普通的switch…case或if…else if…else结构，而直接示出以下表驱动实现：
, e* t  w! F( v( x& i& ]typedef struct{
    PORTSTATE loopMEState;
3 P3 U, O. d( Y    PORTSTATE loopMIBState;
. ^. b( A  c) @) g( J$ x}LOOPMAPSTRUCT;
, w5 K' B4 q! u0 {, z
( }0 h8 g: Z# s7 F* Astatic LOOPMAPSTRUCT s_CesLoop[] = {
/ Z3 y( e5 E/ \2 m% z& k    {NO_LOOP,                  e_ds1_looptype_noloop},
0 @& ^9 F6 U9 n4 `+ r* a  ~    {PAYLOAD_LOOP,             e_ds1_looptype_PayloadLoop},
( Y, Z/ f4 i+ P/ B: ^    {LINE_LOOP,                e_ds1_looptype_LineLoop},
+ N& J+ [& |/ w+ q    {PON_LOOP,                 e_ds1_looptype_OtherLoop},
& u2 y, X8 {8 Z$ G* i, T    {CES_LOOP,                 e_ds1_looptype_InwardLoop}};
! q7 [3 `3 s' i2 B6 r+ x6 V8 w& y8 \
PORTSTATE ConvertLoopMEStateToMIBState(PORTSTATE vPortState)
4 K+ }) T* x8 Z# o6 f{
    INT32U num = 0, ii;
8 b& {' w0 b0 y3 x0 }- R1 G" D   
    num = ARRAY_NUM(s_CesLoop);
5 L% {" `) j- [4 q0 h% c    for(ii = 0; ii < num; ii++)
    {
        if(vPortState == s_CesLoop[ii].loopMEState)
            return s_CesLoop[ii].loopMIBState;
8 U5 d6 h: Q3 q7 G7 U" v3 {- u$ I    }
    return e_ds1_looptype_noloop;
}


6 V- K9 z! z1 a: @+ n3 ?4 _) B相应地，从loopMIBState映射到loopMEState需要定义一个ConvertLoopMIBStateToMEState函数。更进一步，所有类似的一对一映射关系都必须如上的映射(转换)函数，相当繁琐。事实上，从抽象层面看，该映射关系非常简单。提取共性后定义带参数宏，如下所示：
5 U5 ?( N5 _+ @4 a( M& W- u8 U/**********************************************************
- o9 @+ x4 Q/ `+ X* 功能描述：进行二维数组映射表的一对一映射，用于参数适配
* 参数说明：map        -- 二维数组映射表
0 n, R: A+ Q/ v! a            elemSrc    -- 映射源，即待映射的元素值
( N2 p0 [' q) B: m, B" O            elemDest   -- 映射源对应的映射结果
: W5 [- R2 m+ {            direction  -- 映射方向字节，表示从数组哪列映射至哪列。
                          高4位对应映射源列，低4位对应映射结果列。
3 X+ M6 J4 p5 y4 b2 P1 v; S            defaultVal -- 映射失败时置映射结果为缺省值
* 示例：ARRAY_MAPPER(gCesLoopMap, 3, ucLoop, 0x10, NO_LOOP);
            则ucLoop = 2(LINE_LOOP)
**********************************************************/
" m3 C2 m( [6 K7 m#define ARRAY_MAPPER(map, elemSrc, elemDest, direction, defaultVal) do{\
    INT8U ucMapIdx = 0, ucMapNum = 0; \
    ucMapNum = sizeof(map)/sizeof(map[0]); \
    for(ucMapIdx = 0; ucMapIdx < ucMapNum; ucMapIdx++) \
    { \
        if((elemSrc) == map[ucMapIdx][((direction)&0xF0)>>4]) \
        { \
            elemDest = map[ucMapIdx][(direction)&0x0F]; \
            break; \
        } \
$ d" p( W- U# |4 m& c9 w    } \
    if(ucMapIdx == ucMapNum) \
8 k$ k; I# l2 E% s+ g% |    { \
        elemDest = (defaultVal); \
0 S  G2 z$ R3 [$ C    } \
' t* e& s# V5 R( W0 _8 V) Z}while(0)


参数取值转换时直接调用统一的映射器宏，如下：
9 `; Q: E. o$ ?5 R. h( m( Q$ bstatic INT8U gCesLoopMap[][2] = {
6 V8 S/ x* S9 m  U3 G: ~    {NO_LOOP,                  e_ds1_looptype_noloop},
0 h: T: z% y+ w" U    {PAYLOAD_LOOP,             e_ds1_looptype_PayloadLoop},
    {LINE_LOOP,                e_ds1_looptype_LineLoop},
# J7 Q. A, i* b. C) p: [4 |    {PON_LOOP,                 e_ds1_looptype_OtherLoop},
    {CES_LOOP,                 e_ds1_looptype_InwardLoop}};
  |# M; j1 M+ d- y% d( E/ w6 |
ARRAY_MAPPER(gCesLoopMap, tPara.dwParaVal[0], dwLoopConf, 0x01, e_ds1_looptype_noloop);


* _% O* _. b) H! T另举一例：
#define  CES_DEFAULT_JITTERBUF        (INT32U)2000   /* 默认jitterbuf为2000us，而1帧=125us */
6 \* x' E; d& i) J& P0 z1 v$ p& x#define  CES_JITTERBUF_STEP           (INT32U)125    /* jitterbuf步长为125us，即1帧 */
#define  CES_DEFAULT_QUEUESIZE        (INT32U)5
6 D( D# i" Y  C0 F# u0 s; K/ O8 o- D#define  CES_DEFAULT_MAX_QUEUESIZE    (INT32U)7
% X+ N! G( s9 \8 u% d/ J" g
/ O: [" ~, I. r#define  ARRAY_NUM(array)             (sizeof(array) / sizeof((array)[0]))  /* 数组元素个数 */
- Z/ z: ]. @4 U" {0 d6 p" e5 Otypedef struct{
% x# h& l3 }& P" v) ^4 D( i$ l& [    INT32U  dwJitterBuffer;
    INT32U  dwFramePerPkt;
    INT32U  dwQueueSize;
# J4 \4 [& h0 X. }& k) ]0 A}QUEUE_SIZE_MAP;
/* gCesQueueSizeMap也可以(JitterBuffer / FramePerPkt)值为索引，更加紧凑 */
$ b) Y# B9 }0 {2 Y) r4 |) fstatic QUEUE_SIZE_MAP gCesQueueSizeMap[]= {
3 G1 f/ G. E5 J+ S5 r3 R       {1,1,1},  {1,2,1},  {2,1,2},  {2,2,1},
       {3,1,3},  {3,2,1},  {4,1,3},  {4,2,1},
       {5,1,4},  {5,2,3},  {6,1,4},  {6,2,3},
9 h6 k" T5 L; E- T5 J+ f       {7,1,4},  {7,2,3},  {8,1,4},  {8,2,3},
       {9,1,5},  {9,2,4},  {10,1,5}, {10,2,4},
       {11,1,5}, {11,2,4}, {12,1,5}, {12,2,4},
" N' P- P/ D& J: n& F       {13,1,5}, {13,2,4}, {14,1,5}, {14,2,4},
% g0 m7 f- ?$ u- g( Y       {15,1,5}, {15,2,4}, {16,1,5}, {16,2,4},
       {17,1,6}, {17,2,5}, {18,1,6}, {18,2,5},
       {19,1,6}, {19,2,5}, {20,1,6}, {20,2,5},
       {21,1,6}, {21,2,5}, {22,1,6}, {22,2,5},
       {23,1,6}, {23,2,5}, {24,1,6}, {24,2,5},
       {25,1,6}, {25,2,5}, {26,1,6}, {26,2,5},
       {27,1,6}, {27,2,5}, {28,1,6}, {28,2,5},
* U  [# a4 f% m1 J       {29,1,6}, {29,2,5}, {30,1,6}, {30,2,5},
& T" M7 c9 {* o2 h( w( I% D       {31,1,6}, {31,2,5}, {32,1,6}, {32,2,5}};
/**********************************************************
9 i/ x/ p2 r8 k, }& H7 Q3 ~2 W* 函数名称：CalcQueueSize
* 功能描述：根据JitterBuffer和FramePerPkt计算QueueSize
. K$ o7 B1 v4 `6 d* 注意事项：配置的最大缓存深度
7 B% B$ U5 g% S*            = 2 * JitterBuffer / FramePerPkt
*            = 2 * N Packet = 2 ^ QueueSize
3 J& A4 H: C) U/ K% o0 J& A*            JitterBuffer为125us帧速率的倍数，
2 J: @( o) c- K0 R*            FramePerPkt为每个分组的帧数，
*            QueueSize向上取整，最大为7。
* s0 f9 J+ `4 m; ~: b5 o/ \**********************************************************/
6 N: H1 l( K" oINT32U CalcQueueSize(INT32U dwJitterBuffer, INT32U dwFramePerPkt)
! k% m9 @; W7 |  l; L7 T{
8 z- F- b% [! q( P% p6 j, G6 s    INT8U ucIdx = 0, ucNum = 0;

, E! O7 ?6 n5 T0 a$ [& _7 T    //本函数暂时仅考虑E1
    ucNum = ARRAY_NUM(gCesQueueSizeMap);
    for(ucIdx = 0; ucIdx < ucNum; ucIdx++)
    {
       if((dwJitterBuffer == gCesQueueSizeMap[ucIdx].dwJitterBuffer) &&
$ ^* T; X& B, y2 @) ^( D8 X          (dwFramePerPkt == gCesQueueSizeMap[ucIdx].dwFramePerPkt))
       {
            return gCesQueueSizeMap[ucIdx].dwQueueSize;
       }
    }
   
    return CES_DEFAULT_MAX_QUEUESIZE;
}
1 c; [; E: @  t9 f
8 B# @$ E. R% R) `) M
# ^# g! T/ X3 w8 }. |1.2.6版本控制

问题：控制OLT与ONU之间的版本协商。ONU本地设置三比特控制字，其中bit2(MSB)~bit0(LSB)分别对应0x21、0x30和0xAA版本号；且bitX为0表示上报对应版本号，bitX为1表示不上报对应版本号。其他版本号如0x20、0x13和0x1必须上报，即不受控制。

最初的实现采用if…else if…else结构，代码非常冗长，如下：
pstSendTlv->ucLength = 0x1f;
if (gOamCtrlCode == 0)
6 q: M' U! Y. d5 ]8 C* U8 V1 \{
! U  q0 a: [" C) T- r    vosMemCpy(pstSendTlv->aucVersionList, ctc_oui, 3);
8 \0 F+ e% {, A% o* |' [* N" r    pstSendTlv->aucVersionList[3] = 0x30;
- D" [; d3 U- m+ q5 [% ]; ^5 _9 Y    vosMemCpy(&(pstSendTlv->aucVersionList[4]), ctc_oui, 3);
    pstSendTlv->aucVersionList[7] = 0x21;
    vosMemCpy(&(pstSendTlv->aucVersionList[8]), ctc_oui, 3);
) J, ^/ Y3 Q) @6 m    pstSendTlv->aucVersionList[11] = 0x20;
, e) o/ |1 v) f    vosMemCpy(&(pstSendTlv->aucVersionList[12]), ctc_oui, 3);
2 y3 |( |/ i( }; O: J' W* w% ]    pstSendTlv->aucVersionList[15] = 0x13;
' z( n$ e0 ~, D4 q# L    vosMemCpy(&(pstSendTlv->aucVersionList[16]), ctc_oui, 3);
    pstSendTlv->aucVersionList[19] = 0x01;
    vosMemCpy(&(pstSendTlv->aucVersionList[20]), ctc_oui, 3);
1 E9 w8 ?& c3 x( O    pstSendTlv->aucVersionList[23] = 0xaa;
}
else if (gOamCtrlCode == 1)
{
% T% M( p3 V& t3 g0 T& p  A! z# u    vosMemCpy(pstSendTlv->aucVersionList, ctc_oui, 3);
9 b. x; b; G8 P    pstSendTlv->aucVersionList[3] = 0x30;
; {  R. |0 Y, L7 Y2 ]3 ~! N, t    vosMemCpy(&(pstSendTlv->aucVersionList[4]), ctc_oui, 3);
& h# j# A. f: }* Q% E- q. F    pstSendTlv->aucVersionList[7] = 0x21;
- U" x: H0 {- d' i& Z; I& H9 X8 \    vosMemCpy(&(pstSendTlv->aucVersionList[8]), ctc_oui, 3);
3 I% s0 ?- y/ o5 J; H* x1 j& H3 O    pstSendTlv->aucVersionList[11] = 0x20;
' i7 c2 @9 B. y. f2 ?; _    vosMemCpy(&(pstSendTlv->aucVersionList[12]), ctc_oui, 3);
    pstSendTlv->aucVersionList[15] = 0x13;
( c, A2 s1 p; d: ?    vosMemCpy(&(pstSendTlv->aucVersionList[16]), ctc_oui, 3);
2 ^) ]# s  e; A4 s$ k    pstSendTlv->aucVersionList[19] = 0x01;
}
; t8 X; X2 B" f/ d2 C//此处省略gOamCtrlCode == 2~6的处理代码
else if (gOamCtrlCode == 7)
' M. V8 j7 v! Q' ^1 c+ ]& u2 |{
    vosMemCpy(&(pstSendTlv->aucVersionList), ctc_oui, 3);
    pstSendTlv->aucVersionList[3] = 0x20;
    vosMemCpy(&(pstSendTlv->aucVersionList[4]), ctc_oui, 3);
    pstSendTlv->aucVersionList[7] = 0x13;
5 M7 G6 g5 |5 b' ~    vosMemCpy(&(pstSendTlv->aucVersionList[8]), ctc_oui, 3);
" \( c- g* Q- T9 v    pstSendTlv->aucVersionList[11] = 0x01;
}

' N3 d* D. d1 n" M
* Z$ i" _9 ?- b/ A5 `# `以下示出C语言中更简洁的实现方式(基于二维数组)：
/**********************************************************************
  f- i! ]! M7 \0 O8 A6 K9 u$ G; o* 版本控制字数组定义
* gOamCtrlCode:   Bitmap控制字。Bit-X为0时上报对应版本，Bit-X为1时屏蔽对应版本。
1 |8 W: k: L; X6 M0 L6 I; m+ C* CTRL_VERS_NUM:  可控版本个数。
* CTRL_CODE_NUM:  控制字个数。与CTRL_VERS_NUM有关。
* gOamVerCtrlMap: 版本控制字数组。行对应控制字，列对应可控版本。
1 S; B# T  M7 k9 u9 ?6 j                  元素值为0时不上报对应版本，元素值非0时上报该元素值。
* Note: 该数组旨在实现“数据与控制隔离”。后续若要新增可控版本，只需修改
4 Z' @4 [' g. V9 V2 H1 c4 c                  -- CTRL_VERS_NUM
                  -- gOamVerCtrlMap新增行(控制字)
  L8 W6 d! J& O5 g9 i0 G                  -- gOamVerCtrlMap新增列(可控版本)
) T! N) m. j* \# q' o5 U1 O**********************************************************************/
#define CTRL_VERS_NUM    3
8 _; {1 `4 d, D2 w0 x+ G#define CTRL_CODE_NUM    (1<<CTRL_VERS_NUM)
( N, P8 p$ I6 E4 M2 m6 C) z# ^% w* P0 lu8_t gOamVerCtrlMap[CTRL_CODE_NUM][CTRL_VERS_NUM] = {
6 H6 o% o$ c: L! ^# ], r7 @  Z /* Ver21         Ver30        VerAA */
    {0x21,         0x30,        0xaa},    /*gOamCtrlCode = 0*/
% Z2 o# w7 N( o6 T  W* x- V; C, T    {0x21,         0x30,          0 },    /*gOamCtrlCode = 1*/
    {0x21,           0,         0xaa},    /*gOamCtrlCode = 2*/
    {0x21,           0,           0 },    /*gOamCtrlCode = 3*/
1 j( m0 K5 e; N9 s. N    {  0,          0x30,        0xaa},    /*gOamCtrlCode = 4*/
5 @, A0 T" Z  c    {  0,          0x30,          0 },    /*gOamCtrlCode = 5*/
    {  0,            0,         0xaa},    /*gOamCtrlCode = 6*/
, o$ e  J# v2 Q$ D0 |    {  0,            0,           0 }     /*gOamCtrlCode = 7*/
" Q: y% h7 I- Q4 j* K$ }};
#define INFO_TYPE_VERS_LEN    7  /* InfoType + Length + OUI + ExtSupport + Version */

4 f3 Q2 B) H1 a8 c9 i- m/ M# vu8_t verIdx = 0;
u8_t index = 0;
4 ?; d; l3 Y2 H5 N; [  Afor(verIdx = 0; verIdx < CTRL_VERS_NUM; verIdx++)
{
    if(gOamVerCtrlMap[gOamCtrlCode][verIdx] != 0)
    {
( O: r% a/ J+ k6 k! N        vosMemCpy(&pstSendTlv->aucVersionList[index], ctc_oui, 3);
        index += 3;
        pstSendTlv->aucVersionList[index++] = gOamVerCtrlMap[gOamCtrlCode][verIdx];
    }
}
vosMemCpy(&pstSendTlv->aucVersionList[index], ctc_oui, 3);
index += 3;
: d/ z' y, p$ s$ DpstSendTlv->aucVersionList[index++] = 0x20;
* e- P+ W& b& FvosMemCpy(&pstSendTlv->aucVersionList[index], ctc_oui, 3);
6 O  p" R* L$ j0 L1 H. x8 Zindex += 3;
' a! |4 k# Y4 V, Z; e+ a' g5 spstSendTlv->aucVersionList[index++] = 0x13;
vosMemCpy(&pstSendTlv->aucVersionList[index], ctc_oui, 3);
index += 3;
pstSendTlv->aucVersionList[index++] = 0x01;

% E6 G% [1 L& j  m' [: gpstSendTlv->ucLength = INFO_TYPE_VERS_LEN + index;


* \  x: e/ l0 i1.2.7消息处理
$ E9 m1 n' H5 z5 p% L; j

问题：终端输入不同的打印命令，调用相应的打印函数，以控制不同级别的打印。

这是一段消息(事件)驱动程序。本模块接收其他模块(如串口驱动)发送的消息，根据消息中的打印级别字符串和开关模式，调用不同函数进行处理。常见的实现方法如下：
void logall(void)
( n% P0 Z8 [4 y8 x{
+ z% N8 y* ]7 e+ Z1 U    g_log_control[0] = 0xFFFFFFFF;
5 y' E$ `0 u  v) |' @: x: i}

void noanylog(void)
1 ?/ N5 D: F$ W& ^{
/ s- R' C6 Y! G, B) i4 G- m+ X    g_log_control[0] = 0;
0 T" M4 p1 q3 F4 v  E3 B}

void logOam(void)
# ?" y: z2 q4 w1 K4 u  Q* W" v{
$ A* n; r9 u% R: s$ @# S    g_log_control[0] |= (0x01 << FUNCTION_Oam);
* \  e: A0 g& c4 x+ Z}
void nologOam(void)
6 d: J7 k9 }' u* f5 y* ^{
    g_log_control[0] &= ~(0x01 << FUNCTION_Oam);
& [; B( Z* u4 v$ x- u}
/ z) Y3 U  s, l& x5 V/ \' E//... ...
void logExec(char *name, INT8U enable)
{
    CtcOamLog(FUNCTION_Oam,"log %s %d\n",name,enable);
    if (enable == 1) /*log*/
. l# c. m$ g( B( ]    {
- \, [* v9 f1 c% I6 w        if (strcasecmp(name,"all") == 0) { /*字符串比较，不区分大小写*/
- N' g9 ^- Q0 N" [; Q, M            logall();
        } else if (strcasecmp(name,"oam") == 0) {
) B7 E& S3 K/ q3 H7 K2 J3 l6 M/ ]            logOam();
        } else if (strcasecmp(name,"pon") == 0) {
            logPon();
        //... ...
        } else if (strcasecmp(name,"version") == 0) {
            logVersion();
* {6 V( }0 v9 v9 o4 X) I; u+ H( A2 u    }
    else if (enable == 0) /*nolog*/
0 Z: e3 ]  v$ ~. z9 X    {
) w' J& G/ n, w7 Y        if (strcasecmp(name,"all") == 0) {
            noanylog();
/ C, y  a$ M- j8 ]9 ?" }& }        } else if (strcasecmp(name,"oam") == 0) {
. e3 n/ e0 H, ^5 v+ ?- a            nologOam();
" v$ |! S  Y% A8 r0 n        } else if (strcasecmp(name,"pon") == 0) {
            nologPon();
        //... ...
        } else if (strcasecmp(name,"version") == 0) {
            nologVersion();
    }
: s8 T* g$ Q: v* m, O' V7 g# o- a. [    else
    {
3 V5 Y5 j% A' _% F* [" C        printf("bad log para\n");
1 A' C$ R1 l/ v) a& Y. d    }
0 w/ d: L. N9 Q8 M: H, w- g}
1 t9 E6 C% ?# s( g

' F: C1 d  p6 A, {, U6 ^/ ]以下示出C语言中更简洁的实现方式：
" K* t& \, ]' F/ j) K! Mtypedef struct{
$ d1 Y; |8 B( H+ C; ]+ `, ~    OAM_LOG_OFF = (INT8U)0,
    OAM_LOG_ON  = (INT8U)1
, K8 x# O7 O' D! Z}E_OAM_LOG_MODE;
' u9 v4 I5 b, J, L! G/ S2 K: D8 t" wtypedef FUNC_STATUS (*OamLogHandler)(VOID);
" c# k; \+ u9 B# D/ M( Wtypedef struct{
) c6 ~( n$ Z) o7 b7 g    CHAR           *pszLogCls;    /* 打印级别 */
    E_OAM_LOG_MODE eLogMode;      /* 打印模式 */
) q9 J" }0 f- b    OamLogHandler  fnLogHandler;  /* 打印函数 */
}T_OAM_LOG_MAP;

: M0 \# M; Y; U+ ]8 VT_OAM_LOG_MAP gOamLogMap[] = {
    {"all",         OAM_LOG_OFF,       noanylog},
- U1 k5 a* b: W% i- i5 m2 ~  v    {"oam",         OAM_LOG_OFF,       nologOam},
    //... ...
    {"version",     OAM_LOG_OFF,       nologVersion},
1 h3 F% E8 M* g6 Y. u   
7 ]1 x' h, d5 c% n    {"all",         OAM_LOG_ON,        logall},
    {"oam",         OAM_LOG_ON,        logOam},
    //... ...
    {"version",     OAM_LOG_ON,        logVersion}
};
: K& B1 n* _0 @- H3 H$ T/ |INT32U gOamLogMapNum = sizeof(gOamLogMap) / sizeof(T_OAM_LOG_MAP);
7 D$ P7 L$ H: a0 f7 P3 S8 I
VOID logExec(CHAR *pszName, INT8U ucSwitch)
{
    INT8U ucIdx = 0;
    for(; ucIdx < gOamLogMapNum; ucIdx++)
    {
        if((ucSwitch == gOamLogMap[ucIdx].eLogMode) &&
           (!strcasecmp(pszName, gOamLogMap[ucIdx].pszLogCls));
: [9 p" O, o( T6 s5 R; Y        {
: N! d, H1 r1 @) g- q6 {            gOamLogMap[ucIdx].fnLogHandler();
8 [& e9 y- t: X5 E            return;
. q# b( F- `  g" Q2 I  P        }
    }
    if(ucIdx == gOamLogMapNum)
    {
/ _: @3 [& }! N. y4 c( D        printf("Unknown LogClass(%s) or LogMode(%d)!\n", pszName, ucSwitch);
        return;
    }
3 Z/ y" y# q8 R+ f2 P2 \" D- R}


" p% _& r; d# |. S. {& I" ^; d" U( z这种表驱动消息处理实现的优点如下：1.增强可读性，消息如何处理从表中一目了然。2.增强可扩展性。更容易修改，要增加新的消息，只要修改数据即可，不需要修改流程。3.降低复杂度。通过把程序逻辑的复杂度转移到人类更容易处理的数据中来，从而达到控制复杂度的目标。4.主干清晰，代码重用。若各索引为顺序枚举值，则建立多维数组(每维对应一个索引)，根据下标直接定位到处理函数，效率会更高。注意，考虑到本节实例中logOam/logPon或nologOam/nologPon等函数本质上是基于打印级别的比特操作，因此可进一步简化。以下例举其相似实现：
/* 日志控制类型定义 */
0 g/ J$ Y' o# f1 Ktypedef enum
{
& l8 V4 X+ D# S    LOG_NORM = 0,        /* 未分类日志，可用于通用日志 */
    LOG_FRM,             /* Frame，OMCI帧日志 */
3 Y4 z0 j1 Y( V  v6 ^) X6 m    LOG_PON,             /* Pon，光链路相关日志 */
0 O; W3 V( f. D$ d" E3 P    LOG_ETH,             /* Ethernet，Layer2以太网日志 */
    LOG_NET,             /* Internet，Layer3网络日志 */
    LOG_MULT,            /* Multicast，组播日志 */
    LOG_QOS,             /* QOS，流量日志 */
5 c# {9 U+ m/ |  }* a    LOG_CES,             /* Ces，TDM电路仿真日志 */
    LOG_VOIP,            /* Voip，语音日志 */
  r9 C# g9 X+ X4 d* q    LOG_ALM,             /* Alarm，告警日志 */
    LOG_PERF,            /* Performance，性能统计日志 */
/ q2 G7 Q- ^9 l, h% ~4 T    LOG_VER,             /* Version，软件升级日志 */
    LOG_XDSL,            /* xDsl日志 */
- \& F/ T% C3 [4 s6 Z- r    LOG_DB,              /* 数据库操作日志 */
  v0 l$ t5 `$ l  |% \- e6 C( Q    //新日志类型在此处扩展，共支持32种日志类型
/ E  A, Z0 }7 Y7 Z, [* g    LOG_ALL = UINT_MAX   /* 所有日志类型 */
}E_LOG_TYPE;

/*****************************************************************************
' u5 h  ]0 |- e# Y, k * 变量名称：gOmciLogCtrl
: m, M) v0 V5 `, s& @ * 作用描述：OMCI日志控制字，BitMap格式(比特编号从LSB至MSB依次为Bit0->BitN)。
*           Bit0~N分别对应E_LOG_TYPE各枚举值(除LOG_ALL外)。
, w) q/ f, r0 A) B *           BitX为0时关闭日志类型对应的日志功能，BitX为1时则予以打开。
* 变量范围：该变量为四字节整型静态全局变量，即支持32种日志类型。
& Z( J# c4 @9 X$ Y0 W' e2 G* y3 ] * 访问说明：通过GetOmciLogCtrl/SetOmciLogCtrl/OmciLogCtrl函数访问/设置控制字。
*****************************************************************************/
static INT32U gOmciLogCtrl = 0;

//日志类型字符串数组，下标为各字符串所对应的日志类型枚举值。
) T' ^" m* z8 y4 w7 P7 p* c+ P9 Dstatic const INT8U* paLogTypeName[] = {
+ S' D, o; J% `) \    "Norm",        "Frame",   "Pon",  "Ethernet",  "Internet",
    "Multicast",   "Qos",     "Ces",  "Voip",      "Alarm",
- u" ~1 I, M# r: ^    "Performance", "Version", "Xdsl",  "Db"
};
% j! ~  q9 b6 [3 h: N: dstatic const INT8U  ucLogTypeNameNum = sizeof(paLogTypeName) / sizeof(paLogTypeName[0]);

static VOID SetGlobalLogCtrl(E_LOG_TYPE eLogType, INT8U ucLogSwitch)
{
* n" q+ B* o% |/ u    if(LOG_ON == ucLogSwitch)
        gOmciLogCtrl = LOG_ALL;
    else
7 R6 V, ]: w/ ?; C( m7 C        gOmciLogCtrl = 0;
% D( W  `) m! X: Y  ?4 U( g" F- Z}
/ n) |* N. S9 Y3 U8 Qstatic VOID SetSpecificLogCtrl(E_LOG_TYPE eLogType, INT8U ucLogSwitch)
0 e4 w4 V& ]1 y# `9 c( P; F0 l# M3 c{
    if(LOG_ON == ucLogSwitch)
        SET_BIT(gOmciLogCtrl, eLogType);
, e8 i% c7 {- v, {9 H6 e    else
4 Q7 {% l$ {# a; L0 v. i$ m        CLR_BIT(gOmciLogCtrl, eLogType);
. x: E+ Z+ J3 d- u5 l8 A6 d1 W/ z! W}

VOID OmciLogCtrl(CHAR *pszLogType, INT8U ucLogSwitch)
  f7 Q+ K" |# o+ j1 c9 W/ v{
0 P6 L# K8 V+ o$ _  p    if(0 == strncasecmp(pszLogType, "All", LOG_TYPE_CMP_LEN))
    {
        SetGlobalLogCtrl(LOG_ALL, ucLogSwitch);
        return;
    }

    INT8U ucIdx = 0;
    for(ucIdx = 0; ucIdx < ucLogTypeNameNum; ucIdx++)
    {
        if(0 == strncasecmp(pszLogType, paLogTypeName[ucIdx], LOG_TYPE_CMP_LEN))
        {
3 k0 U0 M: F1 ~            SetSpecificLogCtrl(ucIdx, ucLogSwitch);
/ a+ \& Q8 K5 X0 X, y            printf("LogType: %s, LogSwitch: %s\n", paLogTypeName[ucIdx],
                   (1==ucLogSwitch)?"On":"Off");
2 N( d/ b) K2 C) i0 O! O- r  \            return;
: ~8 Y: j4 a+ }" K6 q7 R        }
4 Z1 j: |( w) Y4 Y    }
: K3 Z! E& ]8 |' {/ N) I
    OmciLogHelp();
9 |" R& e* `# o2 D- k}
+ n. o4 f4 p/ A7 \+ F

2 L9 e+ P5 g3 J7 o% L# m1.2.8掩码表

参见《采用掩码方式简化产品国家地区支持能力的表示》一文。

该例实现中用到消息、掩码、函数指针等概念。

2 t4 K9 d1 Y- F8 ^8 q$ T" P4 O! E- f+ [2 编程思想
) x8 k% e! o# V+ n

表驱动法属于数据驱动编程的一种，其核心思想在《Unix编程艺术》和《代码大全2》中均有阐述。两者均认为人类阅读复杂数据结构远比复杂的控制流程容易，即相对于程序逻辑，人类更擅长于处理数据。

本节将由Unix设计原则中的“分离原则”和“表示原则”展开。
: E2 |# g% p' `( m# R$ g8 Z
分离原则：策略同机制分离，接口同引擎分离

机制即提供的功能；策略即如何使用功能。

策略的变化要远远快于机制的变化。将两者分离，可以使机制相对保持稳定，而同时支持策略的变化。代码大全中提到“隔离变化”的概念，以及设计模式中提到的将易变化的部分和不易变化的部分分离也是这个思路。

/ Z& B# p8 @) ]" O! J% W表示原则：把知识叠入数据以求逻辑质朴而健壮
' K3 C5 E$ T- X# \+ }* p7 R

即使最简单的程序逻辑让人类来验证也很困难，但就算是很复杂的数据，对人类来说，还是相对容易推导和建模的。数据比编程逻辑更容易驾驭。在复杂数据和复杂代码中选择，宁可选择前者。更进一步，在设计中，应该主动将代码的复杂度转移到数据中去(参考“版本控制”)。

在“消息处理”示例中，每个消息处理的逻辑不变，但消息可能是变化的。将容易变化的消息和不容易变化的查找逻辑分离，即“隔离变化”。此外，该例也体现消息内部的处理逻辑(机制)和不同的消息处理(策略)分离。数据驱动编程可以应用于：1.函数级设计，如本文示例。2.程序级设计，如用表驱动法实现状态机。3.系统级设计，如DSL。注意，数据驱动编程不是全新的编程模型，只是一种设计思路，在Unix/Linux开源社区应用很多。数据驱动编程中，数据不但表示某个对象的状态，实际上还定义程序的流程，这点不同于面向对象设计中的数据“封装”。

3 附录
3.1网友观点

(以下观点摘自博客园网友“七心葵”的回帖，非常具有启发性。)

Booch的《面向对象分析与设计》一书中，提到所有的程序设计语言大概有3个源流：结构化编程；面向对象编程；数据驱动编程。我认为数据驱动编程的本质是“参数化抽象”的思想，不同于OO的“规范化抽象”的思想。数据驱动编程在网络游戏开发过程中很常用，但是少有人专门提到这个词。数据驱动编程有很多名字：元编程，解释器/虚拟机，LOP/微语言/DSL等。包括声明式编程、标记语言、甚至所见即所得的拖放控件，都算是数据驱动编程的一种吧。数据驱动编程可以帮助处理复杂性，和结构化编程、OO 均可相容。(正交的角度)将变和不变的部分分离，策略和机制分离，由此联想到的还有：(数据和代码的分离，微语言和解释器的分离，被生成代码和代码生成器的分离)；更近一步：(微内核插件式体系结构)元编程应该说是更加泛化的数据驱动编程，元编程不是新加入一个间接层，而是退居一步，使得当前的层变成一个间接层。元编程分为静态元编程(编译时)和动态元编程(运行时)，静态元编程本质上是一种 代码生成技术或者编译器技术；动态元编程一般通过解释器(或虚拟机)加以实现。数据驱动编程当然也不应该说是“反抽象的”，但的确与“OO抽象”的思维方式是迥然不同，泾渭分明的，如TAOUP一书中所述：“在Unix的模块化传统和围绕OO语言发展起来的使用模式之间，存在着紧张的对立关系”应该说数据驱动编程的思路与结构化编程和OO是正交的，更类似一种“跳出三界外，不在五行中”的做法。
) _! M1 Y+ i* D* x- v. D" q6 i
编程和人的关系
& W  M+ v8 t0 P; o$ \* i$ v5 o: D# s

人类心智的限制，一切的背后都有人的因素作为依据：

a人同时关注的信息数量：7+-2 (所以要分模块)b人接收一组新信息的平均时间5s (所以要简单，系统总的模块数不要太多)c人思维的直观性(人的视觉能力和模糊思维能力)，这意味这两点：A“直”——更善于思考自己能直接接触把玩的东西；(所以要“浅平透”、使用具象的设计，要尽量代码中只有顺直的流程)，B“观”——更善于观图而不是推算逻辑；(所以要表驱动法，数据驱动编程，要UML，要可视化编程——当然MDA是太理想化了)d人不能持续集中注意力(人在一定的代码行数中产生的bug数量的比例是一定的，所以语言有具有表现力，要体现表达的经济性)所以要机制与策略分离，要数据和代码分离(数据驱动编程)，要微语言，要DSL，要LOP……e人是有创造欲，有现实利益心的(只要偶可能总是不够遵从规范，或想创造规范谋利——只要成本能承受，在硬件领域就不行)另外，开一个有意思的玩笑，Unix编程艺术艺术的英文缩写为TAOUP，我觉得可以理解为UP之TAO——向上抛出之道——将复杂的易变的逻辑作为数据或更高层代码抛给上层！

- n* a2 `" Q  N8 b7 ^6 {0 ~* m3.2函数指针

“消息处理”一节示例中的函数指针有点插件结构的味道。可对这些插件进行方便替换，新增，删除，从而改变程序的行为。而这种改变，对事件处理函数的查找又是隔离的(隔离变化)。

函数指针非常有用，但使用时需注意其缺陷：无法检查参数(parameter)和返回值(return value)的类型。因为函数已经退化成指针，而指针不携带这些类型信息。缺少类型检查，当参数或返回值不一致时，可能会造成严重的错误。例如，定义三个函数，分别具有两个参数：
int max(int x, int y)  {  return x>y?x:y;  }
1 U8 Z9 ]% N1 i( Eint min(int x, int y)  {  return x<y?x:y;  }
int add(int x, int y)  {  return x+y;  }


而处理函数却定义为：
int process(int x, int y, int (*f)())  {  return (*f)(x, y);  }
3 F" G4 E& {! g6 s$ D
: L9 v7 _. v3 {8 q2 e7 x6 h
# L" {4 }& }$ ]/ u其中，第三个参数是一个没有参数且返回int型变量的函数指针。但后面却用process(a,b,max)的方式进行调用，max带有两个参数。若编译器未检查出错误，而又不小心将return (*f)(x,y);写成return (*f)(x);,那么后果可能很严重。因此在C语言中使用函数指针时，一定要小心"类型陷阱"。

学习了