让你的代码更加优雅的编程技巧-跳转表(置顶)

转载自:https://www.yanbinghu.com/2019/01/20/6807.html?nsukey=kFLEF1Ek4bV4HLe0Dqum%2BJaiMZLqsvyHCf%2Fm%2F1cOp99fzJETfwdsG%2FSU7vq2jiX0Twk3oCAnmutbWO0p3X58iVsXZlZPDxkfdNINr9iD9pz6mIdchN6O91qgGQL98dHEN4pFLv6yogD9tVWcoeviUtjeiGqS4VdL8lrvAQbnEI4%3D

我的以为很不错的文章，因此置顶，转载

前言

前面咱们讲到了《函数指针》，今天咱们看一个编程技巧-函数跳转表。咱们先来看如何实现一个简易计算器。

初始版本

让咱们实现一个简易计算器，咱们首先能想到的方式是什么？switch语句或者if else语句。没错，初学就会想到的两种方式，咱们来看看这种实现方式。这里咱们选择switch语句，定义一个操做类型，用户选择操做类型与操做类型匹配时，选择对应的处理函数进行处理，calc1.c代码以下：

/*calc1.c*/
#include<stdio.h>
#include<stdlib.h>
/*将操做定义为枚举类型*/
typedef enum
{
    OP_ADD = 0,
    OP_SUB,
    OP_MUL,
    OP_DIV,
}OP_TYPE;
/*加减乘除处理函数*/
double ADD(double op1,double op2)
{
    return op1+op2;
}
double SUB(double op1,double op2)
{
    return op1-op2;
}
double MUL(double op1,double op2)
{
    return op1*op2;
}
double DIV(double op1,double op2)
{
    return op1/op2;
}
double calc(int op,double op1,double op2)
{
    /*使用switch，根据操做类型，选择操做*/
    double result = 0;
    switch(op)
    {
        case OP_ADD:
        {
            result = ADD(op1,op2);
            break;
        }
        case OP_SUB:
        {
            result = SUB(op1,op2);
            break;
        }
        case OP_MUL:
        {
            result = MUL(op1,op2);
            break;
        }
        case OP_DIV:
        {
            result = DIV(op1,op2);
            break;
        }
        default:
        {
            printf("unsupport opration\n");
            break;
        }
    }
    return result;
}

int main(int argc,char *argv[])
{  
    if(4 > argc)
    {
        printf("usage:op num1 num2\n");
        printf("op[0:add,1:sub,2:mul;3:div]\n");
        return 0;
    }
    int op = atoi(argv[1]);
    double op1 = atof(argv[2]);
    double op2 = atof(argv[3]);
    printf("op:%d,op1:%.1f,op2:%.1f\n",op,op1,op2);
    double result = calc(op,op1,op2);
    printf("result is %.1f\n",result);
    return 0;
}

　　我运行结果以下：

PS C:\Users\NL\Desktop\ziln\ctest> .\calc.exe 0 2 3
op:0,op1:2.0,op2:3.0
result is 5.0

看似很完美～～

除去编译器对switch进行优化的状况，这种设计方式有如下几个缺点：

• 操做增长时，代码增长，case语句将变得冗长。
• 操做增长时，分支增长，处理对应操做的时间将会增加。
• 代码可维护性较差。

咱们观察代码会发现，每增长一种操做，就须要增长一个分支，当操做愈来愈多的时候calc函数将会变得冗长且不易维护。而且若是没有编译器优化，因为在找到最终匹配的以前，每个case语句都须要执行，所以可能将致使运行时间变长。

函数跳转表版本

既然每个操做对应一个函数，那么彻底能够定义一个函数指针数组，而每一个操做对应一个下标值，只要知道下标值，很快就能够找到对应的函数。咱们都知道，数组下标方式访问数据效率是很高的。该版本实现以下：

#include<stdio.h>
#include<stdlib.h>
/*将操做定义为枚举类型*/
typedef enum
{
    OP_ADD = 0,
    OP_SUB,
    OP_MUL,
    OP_DIV,
} OP_TYPE;
/*入参为double，出参为double的函数指针*/
typedef double (*OP_FUNC)(double, double);
double SUB(double op1,double op2);
double ADD(double op1,double op2);
double MUL(double op1,double op2);
double DIV(double op1,double op2);

typedef struct OP_STRUCT
{
    OP_TYPE opType;//操做类型
    OP_FUNC opFun; //操做函数
} OP_STRUCT;
/*加减乘除处理函数与calc1.c相同，这里省略，可自行添加*/
/*函数跳转表*/
static OP_STRUCT g_opStruct[] =
{
    {OP_ADD, ADD},
    {OP_SUB, SUB},
    {OP_MUL, MUL},
    {OP_DIV, DIV},
};
/*最大操做数量*/
static int g_opNum = sizeof(g_opStruct) / sizeof(OP_STRUCT);
/*加减乘除处理函数*/
double ADD(double op1,double op2)
{
    return op1+op2;
}
double SUB(double op1,double op2)
{
    return op1-op2;
}
double MUL(double op1,double op2)
{
    return op1*op2;
}
double DIV(double op1,double op2)
{
    return op1/op2;
}

double calc(int op, double op1, double op2)
{
    if (op >= g_opNum || op < 0)
    {
        printf("unknow opration\n");
        return 0;
    }
    /*根据操做类型直接选择操做函数*/
    return g_opStruct[op].opFun(op1, op2);
}

/*main函数与calc1.c相同，这里省略*/
int main(int argc, char *argv[])
{
    if (4 > argc)
    {
        printf("usage:op num1 num2\n");
        printf("op[0:add,1:sub,2:mul;3:div]\n");
        return 0;
    }
    int op = atoi(argv[1]);
    double op1 = atof(argv[2]);
    double op2 = atof(argv[3]);
    printf("op:%d,op1:%.1f,op2:%.1f\n", op, op1, op2);
    double result = calc(op, op1, op2);
    printf("result is %.1f\n", result);
    return 0;
}

　　

　　

calc函数中，直接根据操做类型而选择须要的操做处理函数。时间复杂度为O(1)。另外，当须要新增一种操做时，不须要修改calc函数，只须要在函数表g_opStruct中增长一种操做便可。而操做处理是一个返回值为double，入参为两个double的函数，所以使用：

1	typedef double (*OP_FUNC)(double,double);

 

将该类型函数指针定义为OP_FUNC，方面后面的使用。

另外，还能够看到calc函数很简洁，关键代码只有一行。

总结

本文的例子有不少能够优化的地方，例如异常时返回0，可能被当成结果等等，这里只是用switch语句和跳转表做简单的示例。而对于同类型的分支处理，彻底能够考虑使用跳转表的方式，使用跳转表还须要注意的一点就是数组越界。
跳转表只是一种思路，它并非在全部状况下均可以替代switch语句，可根据实际状况决定是否须要使用。

思考

为何在说明第一个版本的简易计算器的时候，强调：除去编译器对switch进行优化的状况？