讓你的代碼更加優雅的編程技巧-跳轉表(置頂)

轉載自: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進行優化的狀況？