1. 项目概述：从需求到架构的思考

最近在带新人，发现很多朋友学C++语法时头头是道，一到要自己动手写个完整的项目就懵了。他们常问：“面向对象那些概念我懂，但怎么用到实际代码里？” 这让我想起自己刚入门时的困惑。于是，我决定用一个最经典的例子——简易计算器，来拆解一次完整的C++面向对象编程实战。别小看这个“简易”计算器，它麻雀虽小，五脏俱全，是理解如何将抽象概念（类、对象、封装、继承、多态）落地为可运行、可维护代码的绝佳练手项目。

这个项目要做的，不是一个简单的cin >> a >> op >> b;然后switch-case输出结果的控制台程序。那只是面向过程。我们要实现的是一个具备图形用户界面（GUI）、能处理复杂表达式、并且设计上易于未来扩展（比如加入科学计算、历史记录功能）的计算器。这背后，正是面向对象思想大显身手的地方：用“类”来模拟现实中的计算器实体，用“对象”来承载具体的计算状态，用“继承与多态”来优雅地支持多种运算。通过这个项目，你不仅能巩固C++基础，更能直观地感受到良好的程序设计如何让代码更清晰、更健壮、更容易应对变化。

2. 核心设计思路与类结构规划

2.1 为什么选择MVC/MVP模式？

计算器虽然功能聚焦，但涉及用户输入、逻辑处理、结果显示等多个层面。如果把所有代码都堆在一起，很快就会变成难以维护的“意大利面条式”代码。因此，我们采用一种经典的分层架构模式。对于这个项目，我推荐MVP（Model-View-Presenter）模式的一个简化变体，它比纯粹的MVC在桌面GUI应用中职责分离更清晰。

• Model（模型）：核心计算引擎。它只关心“怎么算”，不关心“怎么显示”或“用户点了什么”。它负责维护计算状态（如当前输入的数字、操作符）、解析表达式、执行运算规则。这是整个程序最纯粹、最独立的部分。
• View（视图）：用户界面。就是屏幕上那些按钮和显示框。它的职责是接收用户的鼠标/键盘事件，并将这些事件“翻译”成Presenter能理解的操作指令（如“用户按下了数字5”），同时，根据Presenter的指令更新界面显示（如“在显示框输出结果12.5”）。View应该尽可能“笨”，它不包含任何业务逻辑。
• Presenter（主持者/表示器）：连接Model和View的桥梁。它接收来自View的“用户意图”，然后去调用Model的相应方法进行逻辑处理。处理完成后，它再从Model获取最新的数据状态，并通知View更新显示。Presenter包含了大部分的“控制逻辑”。

这样设计的好处是巨大的。假设未来我们要把Qt界面换成控制台界面，或者换成Web界面，只需要重写View层，Model和Presenter的核心逻辑几乎不用动。这就是高内聚、低耦合带来的可维护性和可扩展性。

2.2 核心类职责划分

基于上述模式，我们可以规划出以下几个核心类：

1. CalculatorModel(模型类)：

   • 职责：存储计算数据（如操作数栈、操作符栈），实现表达式求值算法（如调度场算法），提供基本的算术运算接口。
   • 核心属性：可能包括std::string m_currentInput（当前输入字符串）、double m_result（上一次计算结果）、std::stack<double>和std::stack<char>用于表达式求值。
   • 核心方法：inputDigit(int digit),inputOperator(char op),inputDecimal(),clear(),calculate(),getCurrentDisplay()。

2. CalculatorPresenter(主持者类)：

   • 职责：响应View的事件，协调Model进行运算，并更新View的显示。
   • 核心属性：持有CalculatorModel*和CalculatorView*的指针或引用。
   • 核心方法：onDigitClicked(int digit),onOperatorClicked(char op),onEqualsClicked(),onClearClicked()。这些方法内部会调用Model的对应方法，然后调用View的更新方法。

3. CalculatorView(视图抽象基类)：

   • 职责：定义视图的接口。这是一个抽象类，目的是为了解耦Presenter和具体的GUI实现（如Qt、控制台）。
   • 核心方法（纯虚函数）：updateDisplay(const std::string& text),setResult(const std::string& result)。以及一些用于连接信号槽的接口（如果使用Qt）。

4. QtCalculatorView(具体视图类)：

   • 职责：继承自CalculatorView，使用Qt框架实现具体的窗口、按钮和显示框。负责将Qt的信号（如按钮点击）转发给Presenter。
   • 核心属性：各种Qt控件指针，如QLineEdit* display,QPushButton* btnDigits[10]等。
   • 核心方法：实现基类的纯虚函数，并创建具体的GUI布局。

5. 运算类体系（可选但推荐）：

   • 为了演示继承与多态，我们可以定义一个抽象基类Operation。
   • 然后派生出Addition,Subtraction,Multiplication,Division等具体运算类。
   • CalculatorModel可以持有一个std::map<char, Operation*>，将操作符映射到具体的运算对象上。当需要计算时，通过操作符找到对应的运算对象，调用其统一的execute(double a, double b)虚函数。这样，增加一个新的运算（如求幂^），只需要新增一个类并注册到map中，符合开闭原则。

注意：对于第一个版本，如果觉得运算类体系稍显复杂，可以先用简单的函数或switch语句实现。但理解这个设计对掌握面向对象精髓至关重要。

3. 关键实现细节与核心技术点

3.1 表达式求值：调度场算法 vs. 即时计算

计算器的核心难点之一是如何处理运算符优先级和括号。比如输入3 + 5 * 2，正确结果应是13，而不是16。有两种主流策略：

• 即时计算：每次输入一个操作符，就计算前一个操作。这适合简单的连续运算，但无法处理复杂的、带括号的表达式，也无法轻松实现“等号前修改表达式”的功能。
• 表达式求值：将用户输入的整个序列（如3+5*2=）视为一个表达式字符串，使用算法进行求值。这功能强大，是专业计算器的做法。

这里我们选择后者，并采用调度场算法。这个算法由艾兹赫尔·戴克斯特拉引入，用于将中缀表达式（人类习惯的写法，如3+5*2）转换为后缀表达式（逆波兰表示法，如3 5 2 * +），后者没有优先级和括号，求值非常简单。

在CalculatorModel中的实现要点：

1. 维护两个栈：操作数栈和操作符栈。
2. 遍历表达式字符串：
   • 遇到数字，解析完整的数字后压入操作数栈。
   • 遇到操作符op： a. 当操作符栈非空，且栈顶操作符优先级大于等于op时，弹出栈顶操作符和两个操作数进行计算，结果压回操作数栈。 b. 将op压入操作符栈。
   • 遇到左括号(，直接压入操作符栈。
   • 遇到右括号)，不断弹出操作符栈顶进行计算，直到遇到左括号(并弹出它。
3. 遍历结束后，将操作符栈剩余的操作符依次弹出计算。
4. 最终操作数栈顶即为结果。

// CalculatorModel 中的简化示例代码片段 double CalculatorModel::evaluateExpression(const std::string& expr) { std::stack<double> values; std::stack<char> ops; for (size_t i = 0; i < expr.length(); i++) { if (expr[i] == ' ') continue; // 跳过空格 // 处理数字 if (isdigit(expr[i]) || expr[i] == '.') { // ... 解析数字字符串为double，压入values栈 } // 处理左括号 else if (expr[i] == '(') { ops.push(expr[i]); } // 处理右括号 else if (expr[i] == ')') { while (!ops.empty() && ops.top() != '(') { applyOp(values, ops.top()); ops.pop(); } if (!ops.empty()) ops.pop(); // 弹出左括号 } // 处理操作符 else if (isOperator(expr[i])) { // 关键：比较优先级 while (!ops.empty() && precedence(ops.top()) >= precedence(expr[i])) { applyOp(values, ops.top()); ops.pop(); } ops.push(expr[i]); } } // 处理剩余操作符 while (!ops.empty()) { applyOp(values, ops.top()); ops.pop(); } return values.top(); }

3.2 使用Qt实现GUI视图

Qt是一个成熟的C++ GUI框架，信号与槽机制天然适合MVP模式。QtCalculatorView类的核心任务是创建界面，并将Qt信号连接到自身的槽函数，这些槽函数再调用Presenter的接口。

布局与控件创建：通常使用QGridLayout来排列按钮网格。数字按钮0-9、操作符按钮+ - * /、等号=、清除C、小数点.等，每个都是QPushButton。显示框使用QLineEdit，并设置其为只读。

信号与槽的连接：

// 在QtCalculatorView的构造函数或初始化函数中 for (int i = 0; i < 10; ++i) { // 假设btnDigits是QPushButton数组 connect(btnDigits[i], &QPushButton::clicked, this, [this, i]() { // 这里不直接处理逻辑，而是转发给Presenter if (m_presenter) { m_presenter->onDigitClicked(i); } }); } connect(btnPlus, &QPushButton::clicked, this, [this]() { if (m_presenter) m_presenter->onOperatorClicked('+'); }); // ... 连接其他按钮

实现视图接口：

void QtCalculatorView::updateDisplay(const std::string& text) { // 将std::string转换为QString，更新到QLineEdit display->setText(QString::fromStdString(text)); } void QtCalculatorView::setResult(const std::string& result) { // 通常，结果会高亮或特殊显示，这里简单更新 display->setText(QString::fromStdString(result)); }

3.3 运算类的多态设计

为了展示面向对象中“对扩展开放，对修改关闭”的原则，我们设计一个运算类层次结构。

// Operation.h class Operation { public: virtual ~Operation() = default; virtual double execute(double a, double b) const = 0; // 纯虚函数 virtual char getSymbol() const = 0; }; class Addition : public Operation { public: double execute(double a, double b) const override { return a + b; } char getSymbol() const override { return '+'; } }; class Subtraction : public Operation { public: double execute(double a, double b) const override { return a - b; } char getSymbol() const override { return '-'; } }; // ... 定义Multiplication, Division等

在CalculatorModel中，可以这样使用：

class CalculatorModel { private: std::map<char, std::unique_ptr<Operation>> m_operations; public: CalculatorModel() { m_operations['+'] = std::make_unique<Addition>(); m_operations['-'] = std::make_unique<Subtraction>(); m_operations['*'] = std::make_unique<Multiplication>(); m_operations['/'] = std::make_unique<Division>(); } double performOperation(char op, double a, double b) { auto it = m_operations.find(op); if (it != m_operations.end() && it->second) { // 处理除零等特殊情况的检查可以放在Division::execute中 return it->second->execute(a, b); } throw std::invalid_argument("Unsupported operator"); } };

这样，当我们需要增加一个“求余”运算时，只需新增一个Modulus类，并在CalculatorModel的构造函数中注册m_operations['%'] = std::make_unique<Modulus>();即可，无需修改任何现有的运算逻辑代码。

4. 完整实现流程与代码组织

4.1 项目结构与构建

建议的目录结构如下，这有助于管理日益复杂的项目：

SimpleCalculator/ ├── CMakeLists.txt # 使用CMake管理构建 ├── src/ │ ├── model/ │ │ ├── CalculatorModel.cpp │ │ └── CalculatorModel.h │ ├── presenter/ │ │ ├── CalculatorPresenter.cpp │ │ └── CalculatorPresenter.h │ ├── view/ │ │ ├── CalculatorView.h # 抽象接口 │ │ └── qt/ │ │ ├── QtCalculatorView.cpp │ │ └── QtCalculatorView.h │ ├── operations/ # 运算类 │ │ ├── Operation.h │ │ ├── Addition.cpp │ │ └── ... │ └── main.cpp # 程序入口，创建Presenter和View └── resources/ # 可选，存放图标等

使用CMake能方便地管理依赖（如Qt）和跨平台编译。一个基础的CMakeLists.txt需要包含查找Qt包、添加头文件目录、链接Qt库等操作。

4.2 核心流程串联：从点击按钮到显示结果

让我们跟踪一次完整的用户操作：“输入3， 输入+， 输入5， 输入*， 输入2， 输入=”。

1. 用户点击‘3’：

   • QtCalculatorView的按钮槽函数被触发，调用m_presenter->onDigitClicked(3)。
   • CalculatorPresenter::onDigitClicked收到信号，调用m_model->inputDigit(3)。
   • CalculatorModel::inputDigit将数字‘3’追加到当前输入缓冲区m_currentInput中，可能是字符串“3”。
   • Presenter调用m_model->getCurrentDisplay()获取当前显示内容“3”。
   • Presenter调用m_view->updateDisplay("3")。
   • QtCalculatorView::updateDisplay将“3”设置到QLineEdit中。

2. 用户点击‘+’：

   • 流程类似，Presenter调用m_model->inputOperator('+')。
   • CalculatorModel::inputOperator将‘+’追加到m_currentInput，现在缓冲区是“3+”。
   • 显示更新为“3+”。（注意，此时不计算，因为下一个操作数还没输入）

3. 用户点击‘5’， ‘*’， ‘2’：

   • 依次处理，m_currentInput变为“3+5*2”。

4. 用户点击‘=’：

   • Presenter调用m_model->calculate()。
   • CalculatorModel::calculate内部调用evaluateExpression("3+5*2")。
   • 调度场算法开始工作：
     • 遇到3，压入操作数栈。
     • 遇到+，压入操作符栈。
     • 遇到5，压入操作数栈。
     • 遇到*，优先级高于栈顶的+，直接压入操作符栈。
     • 遇到2，压入操作数栈。
     • 表达式结束，开始处理栈：弹出和操作数5、2，计算52=10，结果10压入操作数栈。弹出+和操作数3、10，计算3+10=13，结果13压入操作数栈。
   • 得到结果13，存储在m_result中，并清空或重置m_currentInput。
   • Presenter获取结果，调用m_view->setResult("13")。
   • 视图将显示框内容更新为“13”。

这个过程清晰地展示了数据流和控制流如何在M-V-P三层之间流动，每一层各司其职。

4.3 错误处理与边界情况

一个健壮的计算器必须妥善处理各种异常输入：

1. 除零错误：在Division::execute函数中，如果除数b为0，应抛出异常（如std::runtime_error）或返回一个特殊值（如NaN）。在CalculatorModel::performOperation或calculate中捕获这个异常，然后通过Presenter通知View显示“Error”或“Cannot divide by zero”。
2. 连续操作符：例如输入“3++5”。这取决于设计，可以在inputOperator中判断上一个输入是否是操作符，如果是则替换，或者直接忽略本次输入，或者视为错误。
3. 小数点处理：确保一个数字中只能有一个小数点。在inputDecimal()方法中，需要检查当前正在输入的数字字符串中是否已包含小数点。
4. 表达式不完整：例如输入“3+”后直接按“=”。在evaluateExpression中，这可能导致操作数栈或操作符栈状态异常。需要在求值前或求值过程中进行语法检查。
5. 大数或溢出：C++的double类型有范围限制。对于极端运算结果（如1e308 * 10），可能会得到inf。可以在运算后检查std::isinf()或std::isnan()，并做相应处理。

在Presenter层进行集中错误处理是个好习惯：

void CalculatorPresenter::onEqualsClicked() { try { double result = m_model->calculate(); m_view->setResult(formatResult(result)); // formatResult处理科学计数法显示等 } catch (const std::exception& e) { m_view->showError(e.what()); // View需要实现showError接口，例如用QMessageBox m_model->clear(); // 出错后清空模型状态 } }

5. 常见问题、调试技巧与扩展思考

5.1 开发中常见问题与解决

5.2 调试心得与技巧

• 分模块测试：不要等所有代码写完再测试。先单独测试CalculatorModel的计算逻辑，用简单的控制台程序输入表达式字符串，看输出是否正确。再单独测试QtCalculatorView的界面布局。最后再将它们通过Presenter集成起来。这能极大缩小问题范围。
• 善用Qt Creator调试器：在关键函数（如evaluateExpression,onDigitClicked）设置断点，观察变量值，单步执行，是理解程序流和查找逻辑错误的最有效手段。
• 日志输出：在Presenter的各个方法入口处，用qDebug()打印日志，如qDebug() << “Presenter::onDigitClicked: “ << digit;。这能帮你清晰地看到事件触发的顺序和数据流。
• 处理浮点数精度：计算机中浮点数计算存在精度损失，0.1 + 0.2可能不等于0.3。在显示结果时，可以使用QString::number(result, ‘f’, 10)指定精度，或者自定义比较函数（如fabs(a-b) < 1e-10）。

5.3 项目扩展方向

这个基础框架具有良好的扩展性，你可以尝试添加以下功能来深化练习：

1. 历史记录功能：在CalculatorModel中增加一个std::vector<std::string>来保存每一次完整的表达式和结果。在View中增加一个列表控件（QListWidget）来展示历史。这练习了模型数据的扩展和视图的更新。
2. 科学计算功能：增加sin,cos,log,√等按钮。这需要扩展你的运算类体系。对于单目运算符，需要在调度场算法或模型逻辑中做特殊处理。
3. 括号支持：调度场算法本身支持括号。你只需要在View上增加(和)按钮，并在Model的inputOperator或专门的inputParenthesis方法中处理即可。
4. 界面美化：使用Qt样式表（QSS）来改变按钮颜色、字体、圆角等，打造更现代化的界面。
5. 键盘支持：重写View的keyPressEvent函数，将键盘按键（数字键、回车、退格）映射到相应的Presenter方法上。
6. 单元测试：为CalculatorModel和各个Operation类编写单元测试（使用Google Test等框架）。这能确保你的核心计算逻辑在任何修改后都是正确的，是专业开发的必备技能。

通过这个“简易”计算器项目的完整实现，我希望你收获的不仅仅是一个能运行的程序，更是一种系统性的、面向对象的设计思维。下次当你面对更复杂的项目需求时，你会自然而然地思考：哪些部分应该独立成模型？视图和逻辑如何解耦？哪些行为可以通过多态来抽象？这才是本次实战演练的真正价值所在。