表驱法优化代码

表驱法优化代码md

单片机开发中，时常会遇到需要根据不同的条件执行不同的代码的情况。传统的if-else语句虽然可以解决这个问题，但在条件较多的情况下，代码会显得冗长且难以维护。表驱法（Table-Driven Method）是一种更简洁、更易维护的解决方法。

有多种情况可以使用表驱法进行优化。

1. 优化条件判断

假设我们有一个函数，根据不同的条件执行不同的操作。使用表驱法，我们可以将条件与对应的操作存储在一个表中，然后根据条件查找表中的操作并执行。

typedef struct {
    int condition;
    void (*action)();
} ConditionAction;

void action1() {
    // do something
}

void action2() {
    // do something else
}

void action3() {
    // do something else
}

ConditionAction conditionActions[] = {
    {condition1, action1},
    {condition2, action2},
    {condition3, action3},
};

void executeAction(int condition) {
    for (int i = 0; i < sizeof(conditionActions) / sizeof(conditionActions[0]); i++) {
        if (conditionActions[i].condition == condition) {
            conditionActions[i].action();
            return;
        }
    }
    // default action
}

2. 优化状态机

在状态机中，表驱法可以用来存储状态转换表和动作表，从而简化状态机的实现。

typedef enum {
    STATE_A,
    STATE_B,
    STATE_C,
    STATE_D,
} State;

typedef struct {
    State currentState;
    State nextState;
    void (*action)();
} StateTransition;

void actionA() {
    // do something
}

void actionB() {
    // do something else
}

void actionC() {
    // do something else
}

void actionD() {
    // do something else
}

StateTransition stateTransitions[] = {
    {STATE_A, STATE_B, actionA},
    {STATE_B, STATE_C, actionB},
    {STATE_C, STATE_D, actionC},
    {STATE_D, STATE_A, actionD},
};

void executeStateTransition(State currentState, State input) {
    for (int i = 0; i < sizeof(stateTransitions) / sizeof(stateTransitions[0]); i++) {
        if (stateTransitions[i].currentState == currentState && stateTransitions[i].nextState == input) {
            stateTransitions[i].action();
            return;
        }
    }
    // default action
}

3. 优化配置参数

在配置参数较多的情况下，可以使用表驱法将参数存储在一个表中，然后根据条件查找表中的参数并使用。

typedef struct {
    int condition;
    int parameter;
} ConditionParameter;

int parameter1 = 10;
int parameter2 = 20;
int parameter3 = 30;

ConditionParameter conditionParameters[] = {
    {condition1, parameter1},
    {condition2, parameter2},
    {condition3, parameter3},
};

int getParameter(int condition) {
    for (int i = 0; i < sizeof(conditionParameters) / sizeof(conditionParameters[0]); i++) {
        if (conditionParameters[i].condition == condition) {
            return conditionParameters[i].parameter;
        }
    }
    // default parameter
}

4. 优化数据结构

在数据结构中，表驱法可以用来存储数据结构中的元素，从而简化数据结构的实现。

typedef struct {
    int id;
    char name[20];
} Person;

Person people[] = {
    {1, "Alice"},
    {2, "Bob"},
    {3, "Charlie"},
};

void printPerson(int id) {
    for (int i = 0; i < sizeof(people) / sizeof(people[0]); i++) {
        if (people[i].id == id) {
            printf("Name: %s\n", people[i].name);
            return;
        }
    }
    printf("Person not found\n");
}

5. 优化算法

例如我们需要将一个字符串中的所有字符转换为大写，可以使用表驱法将大小写转换规则存储在一个表中，然后遍历字符串并查找表中的转换规则。

void toUpperCase(char* str) {
    char conversionTable[] = {
        {'a', 'A'},
        {'b', 'B'},
        {'c', 'C'},
        // ...
        {'z', 'Z'},
    };

    for (int i = 0; str[i] != '\0'; i++) {
        for (int j = 0; j < sizeof(conversionTable) / sizeof(conversionTable[0]); j++) {
            if (str[i] == conversionTable[j].from) {
                str[i] = conversionTable[j].to;
                break;
            }
        }
    }
}

再比如需要将一个整数转换成字符串，可以使用表驱法将数字和字符的对应关系存储在一个表中，然后遍历数字并查找表中的对应关系。这样可以将数组的索引作为数字，将数组的值作为字符，从而简化代码。

void intToString(int num, char* str) {
    char conversionTable[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};

    int i = 0;
    do {
        str[i++] = conversionTable[num % 10];
        num /= 10;
    } while (num > 0);

    str[i] = '\0';
    reverse(str);
}

, ‘6’, ‘7’, ‘8’, ‘9’};

int i = 0;
do {
    str[i++] = conversionTable[num % 10];
    num /= 10;
} while (num > 0);

str[i] = '\0';
reverse(str);

}