从OJ题到工程实践：用C++构建健壮的命令行计算器

在信息学竞赛的练习中，我们常常会遇到像2058题这样的"简单计算器"题目。这类题目通常只需要处理最基本的四则运算，但在实际工程开发中，一个真正可用的计算器需要考虑更多因素：持续交互、错误处理、代码结构优化等。本文将带你从一道OJ题出发，逐步构建一个具有工程价值的命令行计算器。

1. 基础功能实现与交互设计

我们先从题目要求的基本功能出发，但不再局限于单次运算，而是实现一个可以持续接收用户输入的计算器。以下是基础版本的实现：

#include <iostream>
#include <string>
using namespace std;

double calculate(double a, double b, char op) {
    switch(op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': 
            if(b == 0) throw runtime_error("除零错误");
            return a / b;
        default: throw runtime_error("无效运算符");
    }
}

int main() {
    cout << "命令行计算器 (输入q退出)" << endl;
    while(true) {
        cout << "> ";
        string input;
        getline(cin, input);
        
        if(input == "q") break;
        
        double a, b;
        char op;
        istringstream iss(input);
        if(!(iss >> a >> op >> b)) {
            cout << "输入格式错误" << endl;
            continue;
        }
        
        try {
            double result = calculate(a, b, op);
            cout << "结果: " << result << endl;
        } catch(const exception& e) {
            cout << "错误: " << e.what() << endl;
        }
    }
    return 0;
}

这个版本已经比原始题目中的解决方案有了显著改进：

• 使用函数封装计算逻辑
• 支持持续交互而非单次计算
• 添加了基本的错误处理机制
• 提供了更友好的用户界面

2. 高级错误处理与输入验证

在实际应用中，用户输入可能千奇百怪，我们需要更健壮的输入验证机制。以下是改进后的输入处理：

bool parseInput(const string& input, double& a, char& op, double& b) {
    istringstream iss(input);
    string temp;
    
    // 尝试读取第一个操作数
    if(!(iss >> a)) {
        // 可能是科学计数法或其他格式
        iss.clear();
        if(!(iss >> temp)) return false;
        
        try {
            a = stod(temp);
        } catch(...) {
            return false;
        }
    }
    
    // 读取运算符
    if(!(iss >> op)) return false;
    
    // 验证运算符有效性
    if(op != '+' && op != '-' && op != '*' && op != '/') {
        return false;
    }
    
    // 尝试读取第二个操作数
    if(!(iss >> b)) {
        iss.clear();
        if(!(iss >> temp)) return false;
        
        try {
            b = stod(temp);
        } catch(...) {
            return false;
        }
    }
    
    // 检查是否有多余字符
    string remaining;
    if(iss >> remaining) return false;
    
    return true;
}

这个解析函数可以处理更多边界情况：

• 科学计数法输入（如1e3）
• 更宽松的数字格式
• 严格的运算符验证
• 多余字符检测

3. 代码模块化与架构优化

为了提升代码的可维护性和可扩展性，我们可以将计算器拆分为多个模块：

Calculator/
├── calculator.h    // 接口定义
├── calculator.cpp  // 实现
├── parser.h        // 输入解析
├── parser.cpp
├── error.h         // 错误处理
└── main.cpp        // 主程序

calculator.h 内容示例：

#pragma once
#include <stdexcept>
#include <string>

class Calculator {
public:
    double calculate(double a, double b, char op);
    
    class Error : public std::runtime_error {
    public:
        using std::runtime_error::runtime_error;
    };
    
    class DivisionByZero : public Error {
    public:
        DivisionByZero() : Error("除零错误") {}
    };
    
    class InvalidOperator : public Error {
    public:
        InvalidOperator() : Error("无效运算符") {}
    };
};

这种架构的优势：

• 职责分离，各模块专注单一功能
• 自定义异常层次结构，更精确的错误处理
• 便于单元测试
• 易于扩展新功能（如新增运算符）

4. 测试策略与质量保证

一个健壮的计算器需要全面的测试。我们可以使用C++测试框架如Catch2来编写测试用例：

#define CATCH_CONFIG_MAIN
#include "catch.hpp"
#include "calculator.h"

TEST_CASE("基本运算测试") {
    Calculator calc;
    
    SECTION("加法") {
        REQUIRE(calc.calculate(1, 2, '+') == Approx(3));
        REQUIRE(calc.calculate(-1, 1, '+') == Approx(0));
    }
    
    SECTION("除法边界") {
        REQUIRE_THROWS_AS(calc.calculate(1, 0, '/'), Calculator::DivisionByZero);
    }
    
    SECTION("无效运算符") {
        REQUIRE_THROWS_AS(calc.calculate(1, 1, '^'), Calculator::InvalidOperator);
    }
}

完整的测试策略应该包括：

1. 单元测试 ：验证每个独立组件的正确性
2. 集成测试 ：验证组件间的交互
3. 边界测试 ：特别关注边界条件和异常情况
4. 性能测试 ：对于复杂运算评估响应时间
5. 模糊测试 ：随机输入测试程序的健壮性

5. 扩展功能与进阶方向

基础功能完成后，我们可以考虑以下扩展方向：

5.1 支持复杂表达式

实现一个简单的表达式解析器，支持括号和运算符优先级：

double eval(const string& expr) {
    // 实现一个简单的递归下降解析器
    // 支持 + - * / 和括号
}

5.2 添加历史记录功能

class Calculator {
    vector<string> history;
public:
    void addToHistory(const string& entry) {
        history.push_back(entry);
        if(history.size() > 100) history.erase(history.begin());
    }
    
    void showHistory() const {
        for(const auto& entry : history) {
            cout << entry << endl;
        }
    }
};

5.3 支持变量和函数

class Calculator {
    map<string, double> variables;
public:
    void setVariable(const string& name, double value) {
        variables[name] = value;
    }
    
    double getVariable(const string& name) const {
        auto it = variables.find(name);
        if(it == variables.end()) throw Error("未定义变量");
        return it->second;
    }
};

5.4 添加科学计算功能

double Calculator::calculate(double a, double b, char op) {
    switch(op) {
        // 原有运算符...
        case '^': return pow(a, b);
        case '%': return fmod(a, b);
        // 更多科学计算运算符...
    }
}

6. 工程实践中的经验分享

在实际开发这类工具时，有几个关键点值得注意：

1. 输入验证要严格 ：用户输入永远不可信，必须彻底验证
2. 错误信息要有帮助 ：不要只说"错误"，要说明具体原因和可能的解决方法
3. 代码要可测试 ：设计时要考虑如何方便地测试各个组件
4. 性能不是首要考虑 ：对于这种交互式工具，代码清晰比微优化更重要
5. 文档要完整 ：即使是个人项目，良好的注释和README也很重要

一个实用的技巧是使用 std::regex 来预验证输入格式：

bool validateInputFormat(const string& input) {
    static const regex pattern(R"(\s*([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s+([-+*/%^])\s+([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s*)");
    return regex_match(input, pattern);
}

这个正则表达式可以匹配大多数合法的计算表达式，包括科学计数法。