C++有限状态机实现计算器小程序

C++有限状态机实现计算器小程序攻略

1. 什么是有限状态机？

有限状态机（FSM, Finite State Machine）是一种数学模型，它可以通过状态转移来描述一个系统的行为。在有限状态机中，系统从一个状态转移至另一个状态，这是通过一些输入（input）或者事件（event）来触发的。有限状态机包含三个要素：

• 状态集合
• 输入集合
• 状态转移

2. 怎样实现有限状态机计算器小程序？

有限状态机计算器小程序可以通过以下步骤实现：

• 定义状态集合、输入集合和状态转移；
• 根据状态转移表编写状态转移函数，让程序能够在不同的状态之间进行切换；
• 编写输入处理函数，用于输入的解析和计算；
• 在主函数中，调用输入处理函数和状态转移函数，让程序根据输入进行状态转移和计算。

3. 示例程序说明

我们通过以下两个示例程序来详细说明有限状态机计算器小程序的实现。

示例程序一

以下是一个简单的计算器，只能处理加法和减法。程序开始处于初始状态，当输入"+"或"-"时，程序会进入计算状态。在计算状态下，当输入数字时，程序会将数字保存，并等待下一步的操作符输入。当输入了操作符，并且之前已经有数字被保存了，程序就会进行计算，并返回计算结果。

我们可以先定义三个状态：开始状态、计算状态和结束状态。

enum {
    START_STATE,
    CALCULATE_STATE,
    END_STATE,
};

然后定义输入集合：

enum {
    INPUT_ADD,
    INPUT_SUB,
    INPUT_NUMBER,
    INPUT_END,
};

在实现状态转移函数时，我们可以编写一个包含所有状态转移的表，根据当前状态和输入信息查找下一个状态，以实现状态转移。

static const int STATE_TRANSFORM_TABLE[][4] = {
    /* START_STATE */
    {CALCULATE_STATE, CALCULATE_STATE, START_STATE, END_STATE},
    /* CALCULATE_STATE */
    {END_STATE, END_STATE, CALCULATE_STATE, END_STATE},
    /* END_STATE */
    {END_STATE, END_STATE, END_STATE, END_STATE},
};

最后，实现输入处理函数和主函数，并调用状态转移函数处理输入和状态变化。

void input_handle(int input, int& state, int& result, int number) {
    switch (input) {
    case INPUT_NUMBER:
        result = result * 10 + number;
        break;
    case INPUT_ADD:
        state = STATE_TRANSFORM_TABLE[state][0];
        break;
    case INPUT_SUB:
        state = STATE_TRANSFORM_TABLE[state][1];
        break;
    case INPUT_END:
        state = STATE_TRANSFORM_TABLE[state][2];
        break;
    default:
        break;
    }
}

int main() {
    int state = START_STATE;
    int result = 0;
    int number = 0;
    int input = 0;

    while (true) {
        cin >> input;

        if (input >= '0' && input <= '9') {
            input_handle(INPUT_NUMBER, state, result, input - '0');
        } else if (input == '+') {
            input_handle(INPUT_ADD, state, result, 0);
        } else if (input == '-') {
            input_handle(INPUT_SUB, state, result, 0);
        } else if (input == '=') {
            input_handle(INPUT_END, state, result, 0);
            break;
        }
    }

    cout << "Result is " << result << endl;
    return 0;
}

示例程序二

以下是另一个计算器程序示例，可以处理加、减、乘、除四种运算。同样的，程序开始处于初始状态，当输入一个数字时，程序会进入数字状态，并等待下一次的输入。当输入了操作符，并且之前已经有数字被保存了，程序就会进行计算，并返回计算结果。

首先定义状态集合、输入集合和状态转移表：

enum {
    START_STATE,
    NUMBER_STATE,
    CALCULATE_STATE,
    END_STATE,
};

enum {
    INPUT_PLUS,
    INPUT_MINUS,
    INPUT_MULTIPLY,
    INPUT_DIVIDE,
    INPUT_NUMBER,
    INPUT_END,
};

static const int STATE_TRANSFORM_TABLE[][6] = {
    /* START_STATE */
    {NUMBER_STATE, NUMBER_STATE, NUMBER_STATE, NUMBER_STATE, NUMBER_STATE, END_STATE},
    /* NUMBER_STATE */
    {END_STATE, END_STATE, END_STATE, END_STATE, NUMBER_STATE, CALCULATE_STATE},
    /* CALCULATE_STATE */
    {NUMBER_STATE, NUMBER_STATE, NUMBER_STATE, NUMBER_STATE, NUMBER_STATE, END_STATE},
    /* END_STATE */
    {END_STATE, END_STATE, END_STATE, END_STATE, END_STATE, END_STATE},
};

接着定义一个结构体，用来表示一个计算器的状态。

struct CalculatorState {
    int state;
    int number;
    int operatorType;
    int result;

    CalculatorState(int s = START_STATE, int n = 0, int o = 0, int r = 0) :
        state(s), number(n), operatorType(o), result(r) {
    }
};

在输入处理函数中，我们可以通过状态保存的信息来判断下一步该做什么。

void input_handle(int input, CalculatorState& state) {
    switch (input) {
    case INPUT_NUMBER:
        state.number = state.number * 10 + input - '0';
        break;
    case INPUT_PLUS:
    case INPUT_MINUS:
    case INPUT_MULTIPLY:
    case INPUT_DIVIDE:
        if (state.operatorType) {
            state.result = calculate(state.result, state.number, state.operatorType);
            state.number = 0;
        }
        state.operatorType = input;
        state.state = STATE_TRANSFORM_TABLE[state.state][input - INPUT_PLUS];
        break;
    case INPUT_END:
        if (state.operatorType) {
            state.result = calculate(state.result, state.number, state.operatorType);
        } else {
            state.result = state.number;
        }
        state.state = STATE_TRANSFORM_TABLE[state.state][5];
        break;
    }
}

在主函数只需要不断读取输入并根据状态进行处理即可。

int main() {
    string inputString;
    CalculatorState state;

    while (true) {
        cin >> inputString;

        if (isdigit(inputString[0])) {
            input_handle(INPUT_NUMBER, state);
        } else if (inputString == "+") {
            input_handle(INPUT_PLUS, state);
        } else if (inputString == "-") {
            input_handle(INPUT_MINUS, state);
        } else if (inputString == "*") {
            input_handle(INPUT_MULTIPLY, state);
        } else if (inputString == "/") {
            input_handle(INPUT_DIVIDE, state);
        } else if (inputString == "=") {
            input_handle(INPUT_END, state);
            break;
        }
    }

    cout << "Result is " << state.result << endl;
    return 0;
}

4. 总结

有限状态机是一种强大的数学模型，它可以用于描述各种计算机程序的行为。通过使用有限状态机，我们可以减轻编写复杂程序的负担。在计算器小程序实现中，我们可以通过有限状态机来实现状态的切换和计算操作的处理，让程序更加简洁高效。