10/01|參數傳遞與函式重載(Ch 4)

中山大學 C 程式設計自學指南 Ch 4:傳值與傳參考、const 參考、函式重載、預設引數、用 assert 檢查前置條件,以及 stub 與 driver 測試技巧,附練習題。

發布
更新
字數
5,491
閱讀
約 14 分鐘
瀏覽
82
系列與本頁目錄
  1. 總覽
  2. 環境設置:把工具鏈準備好
  3. 09/10|課程介紹與環境暖身
  4. 09/17|C++ 基礎(Ch 1)
  5. 09/24|流程控制與函式基礎(Ch 2、Ch 3)
  6. 10/01|參數傳遞與函式重載(Ch 4)
  7. 10/08|陣列(Ch 5)
  8. 10/15|結構與類別(Ch 5–6)
  9. 10/22|類別與建構子(Ch 6–7)
  10. 10/29|vector 與運算子重載入門(Ch 7)
  11. 11/05|期中上機考(範圍 Ch 1–6)
  12. 11/12|運算子重載、friend 與 string(Ch 8、Ch 9)
  13. 11/19|指標、動態記憶體與 C 風格字串(Ch 9、Ch 10)
  14. 11/26|分離編譯與命名空間(Ch 11)
  15. 12/03|檔案輸入輸出(Ch 12)
  16. 12/10|繼承(Ch 14)
  17. 12/17|期末筆試(範圍 Ch 1–12、Ch 14)
  18. 12/24|期末上機考(範圍 Ch 1–12、Ch 14)
  19. 附錄:編譯選項、Makefile、錯誤訊息與名詞速查
  1. 傳值(call-by-value):函式改不到外面
  2. 傳參考(call-by-reference):函式可以改到外面
  3. 混合傳值與傳參考
  4. const 參考:又快又安全
  5. 函式重載(overloading)
  6. 預設引數(default arguments)
  7. 用 assert 檢查前置條件
  8. 測試技巧:stub 與 driver
  9. 本週重點回顧
  10. 本週練習題

← 09/24|流程控制與函式基礎(Ch 2、Ch 3) | 回總覽 | 10/08|陣列(Ch 5) →

對應課本習題:Ch4: 3, 7, 8, 9, 14, 17

這幾題各要用到什麼(動手前先看)

主課的上機考幾乎就是這些題目,所以每一題都自己寫過。下表是每題需要的東西(我的歸納,不是題目本文)與本系列對應的練習:

課本題號 要用到的東西 先練
Ch4-3 選單購買:用參考參數在函式裡更新餘額,迴圈到買不起為止 Q5、Q7、Q10
Ch4-7/8/9 單位換算:輸入、計算、輸出各一個函式,if-else 決定換算方向,重複到使用者結束 Q10
Ch4-14 兩個時刻相差幾分鐘(要處理跨午夜)——/、% 拆時分、函式回傳 int 09/17 Q6、Q2
Ch4-17 從分數檔找某個人的分數、跟全部平均比——09/24 的〈從檔案讀入〉+函式回傳值 09/24 讀檔範例、Q2

這週要會什麼

Text
傳值 vs 傳參考 → const 參考 → 函式重載 → 預設引數 → assert/stub/driver

這週要記的東西不多,但筆試超愛考:給你一段程式,問呼叫函式之後外面的變數變成多少。

傳值(call-by-value):函式改不到外面

C++
#include <iostream>
using namespace std;

void addOne(int x) { x = x + 1; }    // x 是「複製品」

int main() {
    int a = 5;
    addOne(a);
    cout << a << '\n';               // 印出 5,沒有變!
    return 0;
}

白話說:呼叫 addOne(a) 時,電腦把 a 的值影印一份給函式。函式在影本上塗改,正本完全沒事。

傳參考(call-by-reference):函式可以改到外面

在參數型別後面加一個 &,意思是「這個參數就是外面那個變數本人,不是複製品」。(注意這個 & 跟 09/17 的 &&「且」沒有關係;它還有第三個用法「取記憶體位址」,11/19 講指標才會遇到。)

C++
#include <iostream>
using namespace std;

void addOne(int& x) { x = x + 1; }   // x 是 a 的「別名」

int main() {
    int a = 5;
    addOne(a);
    cout << a << '\n';               // 印出 6
    return 0;
}

白話說:int& x 不是複製,而是替 a 取了一個小名。在函式裡叫 x,改的就是外面的 a 本人。兩種傳法擺在一起比較:

Text
傳值    main: a=5  ──複製──▶  addOne: x=5 → x=6   (函式結束 x 消失,a 還是 5)
傳參考  main: a ────同一格──── addOne: x           (x 改成 6,就是 a 改成 6)

經典應用——交換兩個變數:

C++
void swapValues(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

如果參數少了 &,這個函式就完全沒有效果——這是初學者最常見的錯誤之一。

另外,int& 只能接變數:addOne(5);、addOne(a + 1); 都會編譯錯誤,訊息裡會出現 cannot bind non-const lvalue reference。lvalue(左值)在這門課先理解成「有名字、住在記憶體裡的東西」(變數;之後學的 a[i]、*p 也算),rvalue(右值)是 5、a + 1 這種「算完就丟的暫時值」——暫時值沒有記憶體位置可以被取小名,所以 int& 只收前者。(正式定義比這複雜:例如 const int x = 1; 的 x 是左值卻不能被指派,本學期不深究。)

混合傳值與傳參考

同一個參數列裡,傳值與傳參考可以混著用。而且參考參數跟 return 不衝突——可以一邊改呼叫端的變數,一邊用回傳值回報狀況:

C++
#include <iostream>
using namespace std;

// 把 score 加上 bonus 分(上限 100),回傳是否被上限截斷
bool addBonus(int& score, int bonus) {
    score += bonus;                  // 等同 score = score + bonus;
    if (score > 100) { score = 100; return true; }
    return false;
}

int main() {
    int s = 95;
    bool capped = addBonus(s, 10);
    cout << s << ' ' << capped << '\n';
    return 0;
}

輸出:

Text
100 1

score 真的被改到了(傳參考),同時用回傳值告訴呼叫者「有沒有撞到上限」——輸出的 1 就是 true(09/17 提過,bool 印出來是 1/0)。

return 一次只能帶回一個值。要一次帶回兩個結果,就改用兩個參考參數:

C++
void minMax(int a, int b, int& mn, int& mx) {
    mn = a < b ? a : b;
    mx = a < b ? b : a;
}

呼叫端先準備兩個變數 int lo, hi;,跑完 minMax(7, 3, lo, hi); 之後 lo 是 3、hi 是 7。

雷區 ①:手滑寫成區域變數

C++
void readScore(int& score) {
    int score2 = score;   // 想先留一份原值,變數卻取了個跟參數只差一字的名字
    cin >> score2;        // 想讀進 score,卻讀進了 score2;外面的 score 完全沒變
}                         // 函式結束,score2 消失

課本稱為 inadvertent local variable:編譯完全不會報錯,但外面的變數一輩子不會變,症狀是「函式明明跑了,值卻沒變」。同名(int score)編譯器會直接擋下來(shadows a parameter),所以真正會出事的永遠是 score2 這種只差一個字的名字。

const 參考:又快又安全

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

void print(const string& s) {   // 不複製字串,也保證不會被改
    cout << s << '\n';
    // s = "oops";              // 編譯錯誤:s 是 const
}

int main() {
    string msg = "hello";
    print(msg);
    print("literal");           // const 參考可以直接接字面值
    return 0;
}

輸出:

Text
hello
literal

複製一個長字串很花時間,& 省掉複製,const 保證不會動到呼叫者的東西。順帶回收前面那條規則:int& 不能接 5 這種暫時值,但 const 型別& 可以——因為保證不會改它,編譯器乾脆替暫時值找塊地方放著,所以上面的 print("literal") 才合法。規則:只讀不改、又比一個 int 大的,一律用 const 型別&(之後學到的 struct、vector 都適用;陣列是例外——它傳進函式時本來就不會複製,10/08 會解釋為什麼)。

三種傳法總整理

情況 寫法
只讀取,資料很小(int、double、char) 傳值 int x
要改到呼叫端的變數,或一次帶回兩個以上的結果 傳參考 int& x
只讀取,但資料比一個數字大(string 等) 傳 const 參考 const string& s

函式重載(overloading)

同一個函式名字,只要參數列表不同(型別不同或個數不同),就可以同時存在:

C++
#include <iostream>
using namespace std;

int    myMax(int a, int b)       { return a > b ? a : b; }
double myMax(double a, double b) { return a > b ? a : b; }
int    myMax(int a, int b, int c){ return myMax(a, myMax(b, c)); }

int main() {
    cout << myMax(3, 7) << '\n';          // 呼叫第一個
    cout << myMax(3.5, 7.25) << '\n';     // 呼叫第二個
    cout << myMax(3, 7, 5) << '\n';       // 呼叫第三個
    return 0;
}

輸出:

Text
7
7.25
7

編譯器根據你傳進去的引數型別與個數決定要呼叫哪一個版本,這個挑選過程叫重載解析(overload resolution)。(有些書把 overloading 譯成「多載」,是同一件事。)

先分清楚兩個詞:提升=往同族、更大、不會失真的型別搬(char/short→int、float→double);轉換=跨族或可能失真(int→double、double→int、int→long)。編譯器偏好提升多過轉換,挑選順序大致是:

  1. 找完全吻合的版本。
  2. 找只需要提升就能吻合的。
  3. 找需要轉換才能吻合的。
  4. 都找不到或同時有兩個一樣好→ 編譯錯誤 call of overloaded ... is ambiguous。

雷區 ②:只有回傳型別不同,不算重載

C++
int  f(int x);
double f(int x);     // 編譯錯誤

因為呼叫 f(3); 時編譯器無從判斷你要哪一個。

雷區 ③:兩邊都要轉型,又一樣好 → 模稜兩可

C++
void show(long x);      // long 是另一種整數型別,大小介於 int 與 long long 之間
void show(double x);
show(5);                // 編譯錯誤:int→long 和 int→double 都是「轉換」,一樣好

g++ 會報 call of overloaded 'show(int)' is ambiguous。對照一下:如果兩個版本是 show(int) 與 show(double),那 show('A') 不會有事,因為 char→int 是型別提升(第 2 順位),贏過轉型(第 3 順位)。寫重載時讓參數型別差異明顯。

預設引數(default arguments)

在參數後面寫 = 值,呼叫時就可以省略這個參數,省略時自動用這個值:

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

void greet(const string& name = "world", char mark = '!') {
    cout << "Hello, " << name << mark << '\n';
}

int main() {
    greet();                 // Hello, world!
    greet("NSYSU");          // Hello, NSYSU!
    greet("NSYSU", '?');     // Hello, NSYSU?
    return 0;
}

輸出:

Text
Hello, world!
Hello, NSYSU!
Hello, NSYSU?

注意這裡順手用了 const string&——參數是參考,一樣可以給預設值。

規則:

  • 有預設值的參數必須放在參數列最右邊(不然呼叫時無法判斷你省略了哪一個)。
  • 預設值只能寫一次:有函式原型就寫在原型,沒有原型就寫在定義;兩邊都寫 g++ 會報 default argument given for parameter 2 ... previous specification。

雷區 ④:預設引數會跟重載打架
同時有 void g(int a); 和 void g(int a, int b = 1); 時,g(5); 兩個都吻合,編譯錯誤 call of overloaded 'g(int)' is ambiguous。

用 assert 檢查前置條件

Ch4 後半換個主題:函式寫多了,怎麼確認它真的對。先從 09/24 那行寫在註解裡的 precondition(前置條件)講起——assert 可以讓那行註解自動被檢查。它是「這件事一定要成立,不成立就讓程式當場停下來」的除錯工具,要 #include <cassert>:

C++
#include <iostream>
#include <cassert>
using namespace std;

double divide(double a, double b) {
    assert(b != 0);          // 前置條件:分母不能是 0
    return a / b;
}

int main() {
    cout << divide(10, 4) << '\n';
    divide(1, 0);            // 違反前置條件
    return 0;
}

輸出(在終端機直接執行):

Text
2.5
app: main.cpp:6: double divide(double, double): Assertion `b != 0' failed.
Aborted (core dumped)

第一行要注意:divide(10, 4) 印的是 2.5 不是 2。10、4 雖然是整數字面值,但參數型別是 double,傳進去的瞬間就先轉成 10.0 和 4.0,所以函式裡算的是 10.0 / 4.0,不是 09/17 的整數除法——引數傳給參數時一樣會做隱式轉換,這正是上面重載解析第 3 順位在講的事。

後兩行就是斷言失敗的樣子:它直接告訴你哪個檔、第幾行、哪個條件掛掉,比自己到處插 cout 找 bug 快得多。

編譯時加上 -DNDEBUG 就會把所有 assert 關掉(正式版不做檢查):

Shell
g++ -std=c++11 -DNDEBUG -o app main.cpp

(-D 是「編譯時定義一個名字」,NDEBUG 是標準規定的固定名字。)實驗課寫作業時放幾個 assert 很好用,但繳交前確認它不會誤觸發。

測試技巧:stub 與 driver

  • Stub(樁):某個函式還沒寫好,先給一個假的實作,讓其他部分能先編譯、先測。
  • Driver(驅動程式):寫一個小 main 專門測試某一個函式,測完再把它接回大程式。

stub 長這樣:

C++
// stub:故意亂答(連 4 都會說是質數),只是為了讓用到它的程式先編譯、先跑起來
bool isPrime(int n) { return n >= 2; }

等外圍都測通了,再換成真正的實作,並配一個 driver 逐一檢查:

C++
#include <iostream>
using namespace std;

bool isPrime(int n) {                 // 要被測試的函式
    if (n < 2) return false;
    for (int i = 2; i <= n / i; i++)
        if (n % i == 0) return false;
    return true;
}

// driver:一個只為了測 isPrime 而存在的 main
int main() {
    for (int n = 1; n <= 10; n++)
        cout << n << " -> " << (isPrime(n) ? "prime" : "not prime") << '\n';
    return 0;
}

輸出:

Text
1 -> not prime
2 -> prime
3 -> prime
4 -> not prime
5 -> prime
6 -> not prime
7 -> prime
8 -> not prime
9 -> not prime
10 -> not prime

這兩個名詞筆試可能考定義,實務上也真的好用:與其整支寫完才編譯,不如寫一個函式測一個。

本週重點回顧

  • 有 & 的參數是別名,在函式裡改它就是改到外面;沒有 & 的參數是複本,怎麼改都動不到呼叫端——這是筆試最愛考的觀念。兩個補充:const 型別& 有 & 但被禁止改;11/19 學指標後會看到「指標本身是複本,但透過它仍能改到指向的東西」。另外 int& 只能接變數。
  • 只讀不改又比一個數字大的東西,一律用 const 型別& 傳:不複製、又保證不被改。
  • 重載看的是參數列表(型別或個數),回傳型別不同不算重載,會編譯錯誤。
  • 預設引數只能放在參數列最右邊,而且原型與定義只能擇一寫。
  • assert(條件) 把前置條件變成會自動檢查的程式碼(要 #include <cassert>);stub 是暫時的假實作,driver 是專門測一個函式的小 main。

本週練習題

Q1. 交換與排序三個數
寫 void swapValues(int& a, int& b),再用它把讀入的三個整數由小到大排序輸出。

Text
輸入: 5 2 9
輸出: 2 5 9
參考解答
C++
#include <iostream>
using namespace std;

void swapValues(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int a, b, c;
    cin >> a >> b >> c;
    if (a > b) swapValues(a, b);
    if (b > c) swapValues(b, c);
    if (a > b) swapValues(a, b);      // 三次比較足以排好三個數
    cout << a << ' ' << b << ' ' << c << '\n';
    return 0;
}

Q2. 一次回傳最大值與最小值
寫 void minMax(int a, int b, int c, int& mn, int& mx),用參考參數把三個數的最小值與最大值帶回呼叫端。

Text
輸入: 7 3 10
輸出: min = 3, max = 10
參考解答
C++
#include <iostream>
using namespace std;

void minMax(int a, int b, int c, int& mn, int& mx) {
    mn = a;
    if (b < mn) mn = b;
    if (c < mn) mn = c;
    mx = a;
    if (b > mx) mx = b;
    if (c > mx) mx = c;
}

int main() {
    int a, b, c, mn, mx;
    cin >> a >> b >> c;
    minMax(a, b, c, mn, mx);
    cout << "min = " << mn << ", max = " << mx << '\n';
    return 0;
}

為什麼要這樣寫? 跟正文的兩數版一樣,只是候選人從兩個變三個。

Q3. 重載 area
寫三個同名函式 area:

  • 一個參數 → 正方形面積
  • 兩個參數 → 長方形面積
  • 三個參數 → 三角形面積(海龍公式)

海龍公式:s=a+b+c2s = \frac{a+b+c}{2},面積 =s(s−a)(s−b)(s−c)= \sqrt{s(s-a)(s-b)(s-c)}

Text
輸入: 3 4 5
輸出:
square   = 9.00
rect     = 12.00
triangle = 6.00
參考解答
C++
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

double area(double side) { return side * side; }
double area(double w, double h) { return w * h; }
double area(double a, double b, double c) {
    double s = (a + b + c) / 2.0;
    return sqrt(s * (s - a) * (s - b) * (s - c));
}

int main() {
    double a, b, c;
    cin >> a >> b >> c;
    cout << fixed << setprecision(2);
    cout << "square   = " << area(a) << '\n';
    cout << "rect     = " << area(a, b) << '\n';
    cout << "triangle = " << area(a, b, c) << '\n';
    return 0;
}

Q4. 帶預設值的利息計算
寫 double compound(double principal, double rate = 0.02, int years = 1),計算複利本利和 P(1+r)nP(1+r)^n,並示範三種呼叫方式。

Text
輸入: 10000
輸出:
default      : 10200.00
rate 5%      : 10500.00
5% for 3 yr  : 11576.25
參考解答
C++
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

double compound(double principal, double rate = 0.02, int years = 1) {
    return principal * pow(1 + rate, years);
}

int main() {
    double p;
    cin >> p;
    cout << fixed << setprecision(2);
    cout << "default      : " << compound(p) << '\n';
    cout << "rate 5%      : " << compound(p, 0.05) << '\n';
    cout << "5% for 3 yr  : " << compound(p, 0.05, 3) << '\n';
    return 0;
}

Q5. 綜合題:加分函式
寫 void applyBonus(const string& name, int& score, int bonus = 5):把 score 加上 bonus(上限 100),再印出名字與加分後的成績;函式開頭用 assert 擋掉負的 bonus。另外寫一個 driver main 測三組資料,其中一組省略 bonus、一組要撞到上限。

Text
輸出:
Amy -> 95
Bob -> 100
Cid -> 100
參考解答
C++
#include <iostream>
#include <string>
#include <cassert>
using namespace std;

void applyBonus(const string& name, int& score, int bonus = 5) {
    assert(bonus >= 0);              // 前置條件:加分不能是負的
    score += bonus;
    if (score > 100) score = 100;    // 上限 100
    cout << name << " -> " << score << '\n';
}

// driver:只為了測 applyBonus 而存在的 main
int main() {
    int amy = 90, bob = 98, cid = 70;
    applyBonus("Amy", amy);          // bonus 省略,用預設值 5
    applyBonus("Bob", bob, 10);      // 撞到上限
    applyBonus("Cid", cid, 30);
    return 0;
}

一題用上本週四個重點:const string&(只讀不改的大東西)、int&(要改到呼叫端)、預設引數、assert 前置條件,外加一個 driver。

實驗課題型加練
以下三題的題型取自去年(2025)第 4 週實驗課的課堂練習(今年這週的投影片還沒出,題目可能會換):同一個 swap 寫傳值版與傳參考版、預設引數、還有一題「反轉相加到迴文」的經典題。題目不是我原創的——練的東西跟去年那幾題一樣,但敘述、規則細節、範例資料和解答都是我自己重寫的,不是原題。Q9 的題型取自歷年考古題(連續輸入、讀到 0 0 結束的最大公因數與最小公倍數),Q10 配合課本勾選題。

Q6. 傳值與傳參考:眼見為憑
寫兩個交換函式 swapByValue(int a, int b) 與 swapByRef(int& a, int& b),函式內交換後各印一次,main 在呼叫前後也各印一次,觀察差別。

Text
輸入: 3 8
輸出:
before: x = 3, y = 8
  inside swapByValue: a = 8, b = 3
after swapByValue: x = 3, y = 8
  inside swapByRef:   a = 8, b = 3
after swapByRef:   x = 8, y = 3
參考解答
C++
#include <iostream>
using namespace std;

void swapByValue(int a, int b) {
    int tmp = a; a = b; b = tmp;
    cout << "  inside swapByValue: a = " << a << ", b = " << b << '\n';
}

void swapByRef(int& a, int& b) {
    int tmp = a; a = b; b = tmp;
    cout << "  inside swapByRef:   a = " << a << ", b = " << b << '\n';
}

int main() {
    int x, y;
    cin >> x >> y;
    cout << "before: x = " << x << ", y = " << y << '\n';
    swapByValue(x, y);
    cout << "after swapByValue: x = " << x << ", y = " << y << '\n';
    swapByRef(x, y);
    cout << "after swapByRef:   x = " << x << ", y = " << y << '\n';
    return 0;
}

函式裡兩個版本印出來一模一樣,差別只在回到 main 之後:傳值版改的是複本,x、y 沒動;傳參考版的 a、b 就是 x、y 的別名,所以真的換了。這題實驗課助教常常追問「為什麼裡面印的一樣、外面不一樣」,要能用「複本 vs 別名」講出來。

Q7. 反轉相加到迴文
把一個數跟它的反轉相加,結果若不是迴文就再做一次,直到出現迴文。例如 87 → 87 + 78 = 165 → 165 + 561 = 726 → 726 + 627 = 1353 → 1353 + 3531 = 4884(迴文)。讀入起始數字,印出每一步、總共加了幾次、最後的迴文;超過 10 次還沒出現就放棄。要求兩個函式:void reverseDigits(long long n, long long& result) 用傳參考帶回反轉結果,bool isPalindrome(long long n) 判斷迴文。

Text
輸入: 87
輸出:
87 + 78 = 165
165 + 561 = 726
726 + 627 = 1353
1353 + 3531 = 4884
steps: 4, palindrome: 4884
Text
輸入: 89
輸出:
89 + 98 = 187
187 + 781 = 968
968 + 869 = 1837
1837 + 7381 = 9218
9218 + 8129 = 17347
17347 + 74371 = 91718
91718 + 81719 = 173437
173437 + 734371 = 907808
907808 + 808709 = 1716517
1716517 + 7156171 = 8872688
gave up after 10 steps
參考解答
C++
#include <iostream>
using namespace std;

// 把 n 反轉後放進 result(用參考帶回去)
void reverseDigits(long long n, long long& result) {
    result = 0;
    while (n > 0) {
        result = result * 10 + n % 10;
        n /= 10;
    }
}

bool isPalindrome(long long n) {
    long long r;
    reverseDigits(n, r);
    return r == n;
}

int main() {
    long long n;
    cin >> n;
    int steps = 0;
    while (!isPalindrome(n) && steps < 10) {
        long long r;
        reverseDigits(n, r);
        cout << n << " + " << r << " = " << n + r << '\n';
        n += r;
        steps++;
    }
    if (isPalindrome(n))
        cout << "steps: " << steps << ", palindrome: " << n << '\n';
    else
        cout << "gave up after 10 steps\n";
    return 0;
}

反轉的邏輯跟 09/24 的 Q3 一樣,只是結果改用參考參數帶回、回傳型別變成 void——這是題目指定的練習重點。用 long long 是因為數字每加一次就長一位,int 撐不到 10 步(89 那組第 10 步已經是七位數再反轉相加)。

Q8. 字尾符號(預設引數)
讀入一個不含空白的字串,用同一個函式 void decorate(const string& s, int len = 0) 印兩次:第一次不給長度,一律在尾端加 .;第二次把字串長度傳進去,長度 ≥ 6 加 !!!、2–5 加 !、1 加 ?。字串長度用 s.size() 取得(string 內建的功能,回傳字元數;10/29 會系統性介紹)。

Text
輸入: makefile
輸出:
makefile.
makefile!!!
Text
輸入: hey
輸出:
hey.
hey!
Text
輸入: k
輸出:
k.
k?
參考解答
C++
#include <iostream>
#include <string>
using namespace std;

// len 省略(或給 0)時:一律加 ".";有給長度時:依長度決定符號
void decorate(const string& s, int len = 0) {
    if (len == 0)      cout << s << ".\n";
    else if (len >= 6) cout << s << "!!!\n";
    else if (len > 1)  cout << s << "!\n";
    else               cout << s << "?\n";
}

int main() {
    string s;
    cin >> s;
    decorate(s);                 // 不看長度
    decorate(s, s.size());       // 看長度
    return 0;
}

預設引數 = 0 讓「沒給長度」變成一個可以判斷的狀態——真正的長度不可能是 0(cin >> s 讀到的字串至少有一個字元),所以 0 可以放心拿來當「沒給」的記號。decorate(s, s.size()) 把 size_t(無號)傳給 int 參數會發生隱含轉換,g++ 在 -Wall -Wextra 下不會警告,而且字串長度不可能大到出問題;想寫得更明確可以用 static_cast<int>(s.size())。

Q9. 最大公因數與最小公倍數
反覆讀入兩個正整數,輸出它們的最大公因數與最小公倍數,讀到 0 0 結束;有非正數就印 invalid。最大公因數用輾轉相除法(09/24 正文寫過的迴圈版):反覆把 (a,b)(a, b) 換成 (b,a mod b)(b, a \bmod b),直到 bb 變成 0,此時 aa 就是答案。

Text
輸入:
12 18
7 5
100000000000 250000000000
0 0
輸出:
gcd = 6, lcm = 36
gcd = 1, lcm = 35
gcd = 50000000000, lcm = 500000000000
參考解答
C++
#include <iostream>
using namespace std;

// 輾轉相除法:反覆把 (a, b) 換成 (b, a % b),b 變 0 時答案就是 a
long long gcd(long long a, long long b) {
    while (b != 0) {
        long long r = a % b;
        a = b;
        b = r;
    }
    return a;
}

long long lcm(long long a, long long b) {
    return a / gcd(a, b) * b;      // 先除再乘,比較不容易溢位
}

int main() {
    long long a, b;
    while (true) {
        cin >> a >> b;
        if (a == 0 && b == 0) break;
        if (a <= 0 || b <= 0) {
            cout << "invalid\n";
            continue;
        }
        cout << "gcd = " << gcd(a, b) << ", lcm = " << lcm(a, b) << '\n';
    }
    return 0;
}

輾轉相除法的迴圈每圈做一次「換成 (b, a % b)」,b 變 0 就停,跟 09/24 正文那份一樣,只是型別改成 long long 裝得下範例的大數。最小公倍數寫成 a / gcd * b 而不是 a * b / gcd:先乘的話 a * b 可能先溢位,就算最後除回來也已經錯了。「讀到 0 0 結束」是實驗課上機考的標準格式,寫成 while (true) 加 break 最直白。

Q10. 換算選單:輸入、計算、輸出各一個函式
反覆讀入選項:1 攝氏轉華氏、2 華氏轉攝氏(選完再讀一個溫度)、0 結束,其他印 unknown choice。規定拆成四個函式:readTemp() 讀一個溫度並回傳、cToF(double)、fToC(double)、printResult(...) 負責印,main 只做選單。結果印到小數一位。

Text
輸入:
1 100
2 98.6
3
0
輸出:
100.0C = 212.0F
98.6F = 37.0C
unknown choice
參考解答
C++
#include <iostream>
#include <iomanip>
using namespace std;

double readTemp() {                       // 輸入:讀一個溫度
    double t;
    cin >> t;
    return t;
}
double cToF(double c) { return c * 9.0 / 5.0 + 32; }      // 計算
double fToC(double f) { return (f - 32) * 5.0 / 9.0; }
void printResult(double from, char unitFrom, double to, char unitTo) {   // 輸出
    cout << fixed << setprecision(1) << from << unitFrom << " = " << to << unitTo << '\n';
}

int main() {
    int choice;
    while (true) {
        cin >> choice;
        if (choice == 0) break;                          // 0 結束
        if (choice == 1) {
            double c = readTemp();
            printResult(c, 'C', cToF(c), 'F');
        } else if (choice == 2) {
            double f = readTemp();
            printResult(f, 'F', fToC(f), 'C');
        } else {
            cout << "unknown choice\n";
        }
    }
    return 0;
}

課本 Ch4 有一組連續三題就是這個骨架:先各寫一個方向的換算,再用 if-else 把兩個方向合成選單,最後包進「重複到使用者結束」的迴圈。main 裡每個分支只有兩行——讀、算+印——因為工作都拆給函式了。


← 09/24|流程控制與函式基礎(Ch 2、Ch 3) | 回總覽 | 10/08|陣列(Ch 5) →

最後更新 2026.09.12

Comments

留言

支援 Markdown、程式碼高亮(```cpp)與 LaTeX($E=mc^2$),Ctrl + Enter 送出。頭像會用你的 e-mail 去 Gravatar 找,e-mail 本身不會公開。

載入留言中…

Esc

輸入關鍵字,例如「線段樹」「Makefile」「面試」。

↑ ↓ 選擇Enter 開啟