Rust 程式設計實踐：打造簡易命令列計算機

– 6 分鐘閱讀

在軟體開發的學習路徑中，將抽象的程式設計理論轉化為具體可執行的應用至關重要。本文以建構基礎計算機為範例，探討如何將結構化程式設計的原則付諸實踐。透過將問題拆解為獨立的功能模組，如輸入處理、運算邏輯與結果呈現，我們不僅能學習 Rust 語言的 enum 與 match 語法，更能體會模組化設計對於提升程式碼可讀性與可維護性的核心價值。這個看似簡單的專案，實則為一個完整的迷你軟體工程實踐，涵蓋從需求分析到程式碼實現的流程，為開發者處理更複雜問題奠定穩固基礎。

軟體工程師的進階修煉：從抽象化到實戰應用的全面提升

第二章：基本概念

構建一個簡單的計算機 (Building a Simple Calculator)

讓我們一步一步地思考這個過程。

1. 定義問題 (Defining the Problem)

我們希望構建一個計算機，它能夠：

  • 提示使用者輸入兩個數字。
  • 要求使用者選擇一個運算符號（+、-、*、/）。
  • 對數字執行選定的運算。
  • 向使用者顯示結果。

2. 規劃組件 (Planning the Components)

為了實現這一點，我們需要：

  • 用於儲存使用者輸入和結果的變數。
  • 用於組織程式碼的函數，用於讀取數字、讀取運算符號和執行計算。
  • 用於表示可能運算集合的列舉。
  • 用於處理使用者輸入和運算選擇的控制流程結構，例如迴圈和 match 表達式。
  • 使用 std::io 模組處理使用者輸入。

3. 編寫程式碼 (Writing the Code)

讓我們開始編碼，邊思考邊進行。

導入 std::io 模組 (Importing the std::io Module)

首先，我們需要處理使用者輸入，因此我們將 std::io 模組引入作用域。

use std::io;

編寫 main 函數 (Writing the main Function)

我們的 main 函數將協調程式的流程。

fn main() {
// 程式碼將在此處添加
}

讀取第一個數字 (Reading the First Number)

我們需要提示使用者輸入第一個數字。

println!("請輸入第一個數字:");
let num1 = read_number();

但是等等——我們還沒有定義 read_number()。讓我們接下來定義它。

定義 read_number 函數 (Defining the read_number Function)

我們需要一個函數，它從使用者那裡讀取輸入，確保它是一個有效的數字，並返回它。

fn read_number() -> f64 {
let mut input = String::new();
loop {
input.clear(); // 清除之前的輸入
io::stdin()
.read_line(&mut input)
.expect("讀取行失敗");
let trimmed = input.trim();

match trimmed.parse::<f64>() {
Ok(num) => return num,
Err(_) => {
println!("無效數字，請重新輸入:");
continue;
}
};
}
}

在這個函數中：

  • 我們創建一個名為 input 的可變 String 來保存使用者的輸入。
  • 我們使用一個迴圈不斷要求輸入，直到輸入一個有效的數字。
  • 我們從標準輸入讀取一行。
  • 我們修剪空白並嘗試將其解析為 f64。
  • 如果解析成功，我們返回該數字。
  • 如果解析失敗，我們通知使用者並繼續迴圈。

讀取第二個數字 (Reading the Second Number)

回到 main 函數中，我們將使用相同的函數讀取第二個數字。

println!("請輸入第二個數字:");
let num2 = read_number();

讀取運算符號 (Reading the Operation)

現在，我們需要詢問使用者他們想要執行的運算。

println!("請輸入運算符號 (+, -, *, /):");
let operation = read_operation();

同樣，我們需要定義 read_operation()。

定義 read_operation 函數 (Defining the read_operation Function)

這個函數將讀取使用者的輸入並返回一個 Operation 列舉變體。

fn read_operation() -> Operation {
let mut input = String::new();

loop {
input.clear(); // 清除之前的輸入
io::stdin()
.read_line(&mut input)
.expect("讀取行失敗");
let op = input.trim();
match op {
"+" => return Operation::Add,
"-" => return Operation::Subtract,
"*" => return Operation::Multiply,
"/" => return Operation::Divide,
_ => {
println!("無效運算符號，請輸入 +, -, *, /:");
continue;
}
}
}
}

這裡發生了什麼：

  • 我們讀取使用者的輸入。
  • 我們修剪它並將其與有效的運算符號進行匹配。
  • 如果匹配，我們返回相應的 Operation 變體。
  • 如果不匹配，我們再次提示使用者。

定義 Operation 列舉 (Defining the Operation Enum)

在使用 Operation 之前，我們需要定義它。

enum Operation {
Add,
Subtract,
Multiply,
Divide,
}

這個列舉代表四種算術運算。

執行計算 (Performing the Calculation)

我們需要一個函數來根據運算執行計算。

fn calculate(a: f64, b: f64, op: Operation) -> f64 {
match op {
Operation::Add => a + b,
Operation::Subtract => a - b,
Operation::Multiply => a * b,
Operation::Divide => a / b,
}
}

在這個 calculate 函數中：

  • 我們使用 match 表達式處理每個 Operation 變體。
  • 每個分支執行相應的算術運算。
  • 我們將結果作為 f64 返回。

顯示結果 (Displaying the Result)

回到 main 函數中，我們將呼叫 calculate 並列印結果。玄貓認為，透過這種模組化的設計，我們不僅實現了計算機的功能，也展示了程式語言在結構化程式碼方面的優勢。

@startuml
!define DISABLE_LINK
!define PLANTUML_FORMAT svg
!theme _none_

skinparam dpi auto
skinparam shadowing false
skinparam linetype ortho
skinparam roundcorner 5
skinparam defaultFontName "Microsoft JhengHei UI"
skinparam defaultFontSize 16
skinparam minClassWidth 100

package "程式語言計算機專案結構" {
node "問題定義與規劃" as ProblemPlanning {
component "目標: 互動式基本算術計算機" as CalculatorGoal
component "輸入兩個數字" as InputTwoNumbers
component "選擇運算符號 (+,-,*,/)" as SelectOperation
component "執行運算並顯示結果" as PerformDisplayResult
component "所需組件: 變數、函數、列舉、控制流、輸入處理" as RequiredComponents
}

node "程式碼實現" as CodeImplementation {
component "導入 std::io 模組" as ImportIO
component "main 函數協調流程" as MainFunctionOrchestration
component "定義 read_number() 函數" as DefineReadNumber
component "循環讀取並驗證數字輸入 (f64)" as LoopReadValidateNumber
component "定義 Operation 列舉" as DefineOperationEnum
component "Operation::Add, Subtract, Multiply, Divide" as OperationVariants
component "定義 read_operation() 函數" as DefineReadOperation
component "循環讀取並匹配運算符號" as LoopReadMatchOperation
component "定義 calculate() 函數" as DefineCalculate
component "使用 match 執行算術運算" as MatchArithmeticOps
component "顯示最終結果" as DisplayFinalResult
}

ProblemPlanning --> CalculatorGoal
ProblemPlanning --> InputTwoNumbers
ProblemPlanning --> SelectOperation
ProblemPlanning --> PerformDisplayResult
ProblemPlanning --> RequiredComponents

CodeImplementation --> ImportIO
CodeImplementation --> MainFunctionOrchestration
CodeImplementation --> DefineReadNumber
CodeImplementation --> LoopReadValidateNumber
CodeImplementation --> DefineOperationEnum
CodeImplementation --> OperationVariants
CodeImplementation --> DefineReadOperation
CodeImplementation --> LoopReadMatchOperation
CodeImplementation --> DefineCalculate
CodeImplementation --> MatchArithmeticOps
CodeImplementation --> DisplayFinalResult

ProblemPlanning -[hidden]-> CodeImplementation
}

@enduml

看圖說話：

此圖示詳細闡述了程式語言計算機專案的結構與實作流程。在問題定義與規劃部分，它明確了專案的目標是構建一個互動式基本算術計算機，並列出了需要輸入兩個數字、選擇運算符號、執行運算並顯示結果等功能需求。同時，也規劃了實現這些功能所需的組件，包括變數、函數、列舉、控制流和輸入處理。接著，在程式碼實現部分，圖示詳細展示了具體的編碼步驟：首先導入 std::io 模組以處理輸入，然後**main 函數作為程式的流程協調者**。隨後，定義了**read_number() 函數**，透過循環讀取並驗證數字輸入，確保輸入的有效性。接著，定義 Operation 列舉來表示加、減、乘、除四種運算變體，並定義 read_operation() 函數來循環讀取並匹配運算符號。最後，定義 calculate() 函數，利用 match 表達式執行算術運算，並由 main 函數負責顯示最終結果。整個流程清晰地展示了如何將程式語言的核心概念應用於實際專案開發。***

結論：從代碼到思維的質變

解構此計算機範例的建構方法後可以發現，其精髓並不僅止於完成一項功能性任務，而是微縮了一次完整的專業軟體開發思維演練。它深刻體現了初階執行者與資深工程師在思維框架上的根本差異。相較於將所有邏輯混雜於一體的線性寫法，這種透過 read_number、calculate 等函數進行的模組化切分，是典型的「關注點分離」實踐。此修煉的真正瓶頸，並非語法掌握，而是克服「立即動手編碼」的慣性，建立起「先設計後實作」的內在紀律。

這種抽象化能力，是軟體工程師職涯發展的關鍵槓桿點。它決定了一位專業人士能處理的複雜度上限，也是從單純的功能開發者，邁向能駕馭大型系統的架構師或技術領導者的分水嶺。未來，隨著技術棧與業務邏輯日益交織，缺乏這種結構化思維的工程師，將會過早觸及其專業天花板。

玄貓認為，對於志在精進的工程師，將此「問題拆解、抽象建模、分而治之」的完整流程內化為思考本能，不僅是提升代碼品質的手段，更是實現個人專業價值躍升的核心路徑。這項修煉的成果，將直接體現在面對未知複雜問題時的從容與洞察力上。

玄貓 BlackCat

玄貓 BlackCat

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。