單行註解：雙斜線 // 開始到該行結尾都屬於「註解」，用來對程式碼做說明。這是給人類看的，對執行完全沒影響。
### 標準輸出 `cout` 是用來將資料輸出到標準輸出(standard output / stdout)，而一般的標準輸出指的是螢幕。 我們可以把它想像成，資料沿著 `<<` 的方向流到螢幕那邊。
提醒：程式碼內容有更動後，都要[save]->[build]，才能[run]。 因為 [build] 會根據你目前的程式碼做出新的執行檔。若沒這麼做，你執行的還是之前舊的執行檔。
## 字串 和 運算式 比較一下這兩行程式碼有什麼不同。 ```C++ cout << "2+3" << endl; cout << 2+3 << endl; ``` 看起來都是 2+3，執行結果卻大不相同。
稍後我們還會看到編譯器給出 `warring` 也就是「警告」的狀況，這是編譯器發現某處可能有問題，但程式依然可以完成編譯並執行。
看懂錯誤訊息後，下一步就是修正它。我們在前面補上宣告即可。 ```C++ #include
學生學號：101, 分數：85.5, 等級：B
---
## 格式化字串的各種變化與應用
接下來是今天的重頭戲。我們可以對 `%` 加上一些「修飾」，來精準控制輸出的樣式。
### **1. 控制輸出寬度 (Field Width)**
我們可以指定一個數字來表示該欄位最少要佔用的寬度。如果實際內容比指定的寬度窄，預設會在**左邊**用空白補滿（也就是**靠右對齊**）。
**語法**：`%[寬度]d`、`%[寬度]f` ...
**範例 2：讓數字整齊排列**
```C++
#include
原始輸出：
123
45
6789
指定寬度為 5 輸出 (靠右對齊)： 123 45 6789
---
### **2. 控制對齊方式 (Alignment)**
如果我們想靠左對齊，只要在寬度數字前加上一個負號 `-` 即可。
**語法**：`%-[寬度]d`、`%-[寬度]s` ...
**範例 3：文字的靠左與靠右**
```C++
#include 指定寬度為 5 輸出 (靠右對齊)： 123 45 6789
--- 商品清單 (寬度 10) ---
靠右對齊: | Apple|
靠左對齊: |Banana |
-------------------------
---
對於浮點數 (%f)，我們可以用 .數字 來指定要顯示到小數點後幾位。注意：系統會自動進行四捨五入。
語法：`%.[位數]f`
**範例 4：計算圓面積並控制精度**
```C++
#include
原始數值：3.141593
顯示到小數點後 2 位：3.14
顯示到小數點後 4 位：3.1416
不顯示小數：3
---
我們也可以將寬度和精度結合起來，創造出更完美的排版。
語法：`%[總寬度].[小數位數]f`
**範例 5：顯示商品價格**
```C++
#include
價格清單 (總寬度 8)：
| 5.99|
| 123.50|
**解說：**
總共佔 8 個字元寬，並且小數點後面固定顯示 2 位，不足的會補 0。
---
### **3. 補零 (Zero Padding)**
如果希望在靠右對齊時，不是補空白而是補 `0`，只要在寬度數字前加上 `0` 即可。這常用於學號、時間等場合。
**語法**：`%0[寬度]d`
**範例 6：顯示學號**
```C++
#include
三年一班 座號列表：
補空白： 7
補零：007
補零：123
---
## 總結與速查表
以下表格提供同學們需要時查詢使用：
|分類|語法|說明與範例|
|---|---|---------|
|基礎類型| %d| 輸出十進位整數 (int)。 `printf("%d", 100);` → `100`|
||%f| 輸出浮點數 (float, double)。 `printf("%f", 12.34);` → `12.340000`|
||%c| 輸出單一字元 (char)。 `printf("%c", 'A');` → `A`|
||%s| 輸出字串 (char 陣列)。 `printf("%s", "Hi");` → `Hi`|
||%%| 輸出 % 符號本身。 `printf("100%%");` → `100%`|
|寬度控制| %[n]d| 輸出寬度至少為 n 的整數，靠右對齊。`printf("%4d",12);` → ` 12`|
||%- [n]d| 輸出寬度至少為 n 的整數，靠左對齊。`printf("%-4d",12);` → `12 `|
|精度控制| %.[n]f| 輸出浮點數，顯示到小數點後 n 位。`printf("%.2f", 3.14159);` → `3.14`|
|組合使用| %[w].[p]f| 總寬度為 w，小數點精度為 p。 `printf("%6.2f", 3.14159);` → ` 3.14`|
|特殊旗標| %0[n]d| 輸出寬度為 n 的整數，不足處在左邊補 0。 `printf("%04d", 55);` → `0055`|
這些符號放在字串中會有特殊功能。
|序列|名稱|功能|
|---|---|----|
|\n |換行符|將游標移至下一行的開頭。|
|\t |定位符|(Tab) 將游標移至下一個定位點，常用於對齊欄位。|
|\\ |反斜線|顯示一個 \ 符號。|
|\" |雙引號|在字串中顯示一個 " 符號。|
## 練習題作業
請同學動手實作，加深對 printf 格式化的理解。
###### 練習題 1：我的個人檔案
* **目標：** 練習 %s, %d, %.1f 的基本使用。
* **說明：** 請宣告變數來儲存姓名、年齡、身高(公尺)，並依照以下格式輸出。
**輸出範例：**
姓名：陳月光
年齡：17 歲
身高：1.7 公尺
---
###### 練習題 2：商品價目表
* **目標：** 練習使用寬度、對齊與小數點精度，製作對齊的表格。
* **說明：** 有三樣商品及其價格如下：
+ "Milk": 65.5 元
+ "Bread": 42 元
+ "Juice": 51.25 元
請使用 printf 格式化功能，輸出如下對齊的價目表。商品名稱欄位寬度為 10 且靠左對齊，價格欄位總寬度為 8 且顯示到小數點後 2 位。
**輸出範例：**
+------------+----------+
| Item | Price |
+------------+----------+
| Milk | 65.50 |
| Bread | 42.00 |
| Juice | 51.25 |
+------------+----------+
---
###### 練習題 3：數位時鐘
* 目標：練習使用補零 0 的技巧。
* 說明：請宣告三個整數變數 h, m, s 分別代表時、分、秒，並賦值 (例如 h=8, m=5, s=30)。請使用 printf 輸出 HH:MM:SS 的格式，也就是不足兩位數時要補零。
**輸出範例：**
目前時間為：08:05:30
# *2.5 C 語言的 scanf( ) 格式化輸入函數
我們已經學會如何用 printf 讓程式輸出精美的訊息。但一個真正有用的程式，不僅要會「說」，更要會「聽」。它需要接收使用者的指令、數據，才能進行下一步的處理。
scanf (scan formatted) 就是這座溝通的橋樑。它會暫停程式的執行，靜靜地等待使用者從鍵盤輸入資料，然後依照我們指定的「格式」去解析這些輸入，並將它們存放到對應的變數中。
同樣地，要使用 scanf，請務必在程式開頭引用標頭檔：
```cpp
#include
請輸入你的年齡：17 (使用者輸入後按 Enter)
請輸入你的身高 (公尺)：1.75 (使用者輸入後按 Enter)
好的，你 17 歲，身高 1.75 公尺。
你可以在格式化字串中放置多個指定符，scanf 會要求使用者一次輸入多個值，並用空白、Tab 或換行鍵來分隔它們。
### 範例 2：輸入座標
```C++
#include
請選擇項目 (1-3): 2 (使用者輸入 2 後按 Enter)
你確定嗎? (Y/N): 你的選擇是 2, 確認字元是 '
'
**問題分析：**
當你輸入 2 並按下 Enter 鍵時，你其實輸入了兩個字元：`'2'` 和 `'\n'` (換行符號)。
`scanf("%d", ...)` 只讀走了 `'2'`，那個 `'\n'` 還留在輸入緩衝區中。輪到 `scanf("%c", ...)` 時，它立刻把還留著的 `'\n'` 讀走了，導致程式根本不等待你輸入 Y 或 N。
**解決方案：**
在 `%c` 前面加一個空格，`" %c"`。這個空格會告訴 scanf：「請忽略前面所有空白類的字元（包含空格、Tab、換行符），然後再讀取下一個真正的字元。」
**範例 3 (正確寫法)：**
```C++
#include
請輸入你的英文全名 (例如: Peter Pan): Peter Pan
你好, Peter！
**問題分析：**
scanf 只讀到了 `"Peter"` 就因為遇到空格而停止了，`"Pan"` 則被留在了後面。
這也是為什麼在 C++ 中，當需要讀取一整行含有空格的文字時，我們未來會學習更適合的 cin.getline() 或 fgets() 函式。
## 2.5.3- 總結與速查表
scanf 是程式接收輸入的基礎，雖然有些小陷阱，但只要小心使用，它依然非常強大。
|指定符|對應資料類型|關鍵提醒|
|-----|----------|------|
|%d|int|變數前記得加 &。例如 `scanf("%d", &num);`|
|%f|float|變數前記得加 &。例如 `scanf("%f", &price);`|
|%lf|double|務必使用 %lf，而非 %f。變數前記得加 &。例如 `scanf("%lf", &pi);`|
|%c|char|變數前記得加 &。若前面有其他輸入，建議用 `" %c"` 來清除換行符。|
|%s|char[]|變數前不用加 &。只能讀取不含空白的字串。|
## 2.5.4- 練習題作業
###### 練習題 1：華氏溫度轉換
* **目標：** 練習讀取浮點數 (double) 並進行計算。
* **說明：** 請使用者輸入攝氏溫度，程式將其轉換為華氏溫度後輸出。
* **公式：** 華氏 = 攝氏 * 9 / 5 + 32
* 執行範例：
```
請輸入攝氏溫度：25.0
轉換後的華氏溫度為：77.0
```
---
###### 練習題 2：簡易對話程式
* **目標：** 綜合練習 %d, %s。
* **說明：** 撰寫一個程式，詢問使用者的名字和學號，然後向他打招呼。
* **執行範例：**
你好！請問你叫什麼名字？ (請輸入英文名)
David
你的學號是幾號？
10123
你好, David (學號: 10123)，歡迎使用本系統！
---
###### 練習題 3：解決字元輸入問題
* **目標：** 練習處理 %c 的換行符陷阱。
* **說明：** 撰寫一個程式，讓使用者輸入一個整數代表分數，然後再輸入一個字元代表評等 (A/B/C/D)。最後將兩者一起輸出。請務必確保程式能正確等待使用者輸入評等。
* **執行範例：**
請輸入你的分數：88
請輸入你的評等 (A-F)：A
你的成績是 88 分，評等為 A。
---
# 03-選擇結構
# 3.1 if ... else ...
## 每一行程式碼都會執行到？
我們寫的每一行程式碼都有用嗎？當然有用。那每一行都會被執行嗎？這要看情況。
之前我們寫的程式，會從 `main()` 函數的第一行開始一行一行依序執行下去，直到程式結束。但在真實世界運作的程式是要有彈性的，例如：指紋鎖必須要在使用者指紋與內部設定吻合時，才會開鎖，否則什麼都不做。也就是這樣一個結構：
`this number is 2.` ```C++ int num = 1; // 這才是我們想要的 switch(num) { case 1: cout << "this number is 1." << endl; break; case 2: cout << "this number is 2." << endl; break; } ``` 程式輸出如下: `this number is 1.` ## Fall-through - 利用沒加 break 的副作用 有時候我們會故意不加 **break** 利用它會一直執行下去的副作用來達到特別的目的。 ###### 練習：各月份所屬的季節 讀取使用者輸入的一個整數 $m, (1 \leq m \leq 12)$，輸出其所屬的季節。 * 2, 3, 4 月：春 * 5, 6, 7 月：夏 * 8, 9, 10 月：秋 * 11, 12, 1 月：冬 這樣寫看起來很累贅。 ```C++ int m; cin >> m switch(month) { case 2: cout << "Spring" << endl; break; case 3: cout << "Spring" << endl; break; case 4: cout << "Spring" << endl; break; case 5: cout << "Summer" << endl; break; case 6: cout << "Summer" << endl; break; case 7: cout << "Summer" << endl; break; case 8: cout << "Fall" << endl; break; case 9: cout << "Fall" << endl; break; case 10: cout << "Fall" << endl; break; default: cout << "Winter" << endl; } ``` 這樣寫就好多了。 ```C++ int m; cin >> m switch(month) { case 2: case 3: case 4: cout << "Spring" << endl; break; case 5: case 6: case 7: cout << "Summer" << endl; break; case 8: case 9: case 10: cout << "Fall" << endl; break; default: cout << "Winter" << endl; } ``` # 3.5 三元運算子 ? : ## 3.5.1 三元運算子？ : 在 C++ 中，三元運算子（Ternary Operator）是唯一一個需要三個運算元的運算子。它的符號是 ? 和 :。 這個運算子主要用來取代簡單的 if-else 判斷式，讓程式碼在一行內就能完成條件判斷與賦值，非常方便。 ### 語法 三元運算子的基本語法結構如下： ```C++ 條件式 ? 運算式1 : 運算式2; ``` 條件式 (Condition): 這是一個會回傳 true (真) 或 false (假) 的布林表達式。 * **? :** 這是三元運算子的核心符號。 * **運算式1 (Expression1):** 如果「條件式」的結果為 true，則執行這個運算式，並將其結果作為整個三元運算式的最終結果。 * **運算式2 (Expression2):** 如果「條件式」的結果為 false，則執行這個運算式，並將其結果作為整個三元運算式的最終結果。 ## 3.5.2 實例練習 讓我們來看幾個例子，比較一下使用 if-else 和使用三元運算子的差別。 ###### 範例：判斷奇偶數 假設我們要讓使用者輸入一個整數，然後判斷它是奇數還是偶數。 **傳統的 if-else 寫法：** ```C++ int number; cout << "請輸入一個整數: "; cin >> number; string result; if (number % 2 == 0) { result = "偶數"; } else { result = "奇數"; } cout << "這個數字是 " << result << endl; ``` **使用三元運算子的寫法：** ```C++ int number; cout << "請輸入一個整數: "; cin >> number; // 一行就搞定！ string result = (number % 2 == 0) ? "偶數" : "奇數"; cout << "這個數字是 " << result << endl; ``` **解說：** 在三元運算子的版本中，(number % 2 == 0) 是我們的條件式。 * 如果 number 除以 2 的餘數為 0 (條件為 true)，則回傳 ? 後面的字串 "偶數"。 * 如果餘數不為 0 (條件為 false)，則回傳 : 後面的字串 "奇數"。 * 最後，回傳的字串會被直接賦值給 result 變數。是不是簡潔很多呢？ 你還可以進一步像這樣直接使用他的運算結果 ```C++ int number; cout << "請輸入一個整數: "; cin >> number; // 注意：要用 ( ) 包覆整個運算式 cout << "這個數字是 " << ((number % 2 == 0) ? "偶數" : "奇數") << endl; ``` ###### 範例：絕對值計算 ```C++ int a; cout << "請輸入一個整數 a: "; cin >> a; cout << "|a|= " << ((a < 0) ? -a : a) << endl; ``` ## 3.5.2 使用時機與注意事項 * **優點：** 程式碼簡潔。 * **缺點：** 不適合處理複雜的邏輯。如果 `if` 或 `else` 區塊中需要執行多行程式碼，就不應該使用三元運算子，否則會讓程式碼變得難以閱讀和維護。 * **原則：** 當 `if-else` 只是為了根據一個簡單條件來賦予變數不同的值時，就是使用三元運算子的最佳時機。 三元運算子 `? :` 是一個非常實用的語法糖 (Syntactic Sugar)，能讓你用更精簡的方式寫出條件判斷。熟練使用它可以提升程式碼的美觀與效率，但切記不要濫用，以免降低複雜邏輯的可讀性。 # 04-重覆結構 # 4.1 while 迴圈 ## 程式執行流程結構 目前為止我們學過了兩種程式執行的流程結構，(1)循序結構；(2)選擇結構。
5
1 2 3 4 5
接下來這題我們來看兩種做法。
###### 輸出 1~n 之間的奇數
**方法一：** 首項為1，公差為2 的等差數列
```C++
int n;
cin >> n;
int i=1; // 首項為 1
while(i<=n)
{
cout << i << " ";
i = i+2; // 公差為 2
}
cout << endl;
```
10
1 3 5 7 9
**方法二：** 在 1~n 之間，逐一過濾符合條件的才輸出
```C++
int n;
cin >> n;
int i=1;
while(i<=n)
{
if(i%2==1)
{
cout << i << " ";
}
i = i+1;
}
cout << endl;
```
10
1 3 5 7 9
就上題來說，**方法一** 比較有效率。但有時候除了逐一過濾檢查之外，沒有更好的辦法。
###### 練習：輸出 n 的所有正因數
某個整數的因數，可不會簡單到成等差數列分布。n 的所有正因數是在 1 ~ n 之間每個可以整除 n 的整數。
```C++
int n;
cin >> n;
cout << n << " 的正因數有：";
int i=1;
while(i<=n)
{
if(n%i==0)
{
cout << i << " ";
}
i = i+1;
}
cout << endl;
```
16
16 的正因數有：1 2 4 8 16
###### 練習：n 有幾個正因數？
這個例子裡，我們要的是正因數的數量，作法為：
1. 將一個用來計數用的變數歸零
2. 每發現一個正因數，就將該計數累加 1
3. 最後輸出該計數值
```C++
int n;
cin >> n;
int sum = 0; // 一開始要給定初值歸零
int i=1;
while(i<=n)
{
if(n%i==0)
{
sum = sum+1;
}
i = i+1;
}
cout << n << " 有 " << sum << " 個正因數" << endl;
```
16
16 有 5 個正因數
## break - 跳出迴圈
有時候我們使用迴圈的目的是要在一個可能範圍中 (1)找出特定目標，(2)確定某條件。所以一但找到或確定了，就可以離開迴圈，不必繼續把後面的圈數跑完。
#### 質數判定
在數學和電腦科學中，判定一個正整數是否為質數是很重要的。如果你去 google 一下，會發現方法有非常多種。在這裡我們使用一個最簡單的概念來實作這個判定 - **「如果一個正整數 n 只有 1 和 n 這兩個因數，則 n 為質數」**。
###### 練習：質數判定(1)
使用前一個「n 有幾個正因數？」程式碼，可以很快完成這個質數判定程式。
正因數數量為 2 的是質數。其他的都不是質數。
```C++
int n;
cin >> n;
int sum = 0;
int i=1;
while(i<=n)
{
if(n%i==0)
{
sum = sum+1;
}
i = i+1;
}
if(sum==2)
{
cout << n << " 是質數" << endl;
}
else
{
cout << n << " 不是質數" << endl;
}
```
###### 練習：質數判定(2)
我們也可以這權想：在 2 ~ (n-1) 之間，如果發現任一個 n 的因數，那麼 n 就不是質數，反之 n 為質數。
下面這個例子，我們先假設 n 是質數，記錄在布林型別的變數 is Prime 中(isPrime = true)。
接著嘗試在 2 ~ (n-1) 之間試試看能否找到 n 的因數。若找到了，表示 n 不是質數，把這個事實記錄下來(isPrime = false)。
在把所有可能的因數都看完後，由 isPrime 的值即可判定 n 是否為質數。
```C++
int n;
cin >> n;
bool isPrime = true; // 先假設 n 是質數 (n is a prime number)
int i=2;
while(i
注意：do ... while(條件判斷式) 最後面有一個分號
使用 do ... while 就可以完美解決我們問題。 ```C++ int answer = 32; // A選定的數字 int yourguess; // 你猜的數字 int count = 0; // 記錄猜了幾次 do { cout << "請猜一個數字(1~100):"; cin >> yourguess; count++; if(yourguess
1 2 3 4 5 6 7 8 9 10
這種情況可以使用 **遞增(increment)運算子** `++` 來處理。
```C++
int i=1;
while(i<10)
(
cout << i << " ";
i++; // 遞增 1
}
cout << endl;
```
1 2 3 4 5 6 7 8 9 10
`i++` 就相當於 `i=i+1`。
同樣的 `i=i-1;` 可以用 **遞減(decrement)運算子** `--` 來處理。
```C++
int i=10;
while(i>0)
(
cout << i << " ";
i--; // 遞減 1
}
cout << endl;
```
10 9 8 7 6 5 4 3 2 1
## 複合指定運算子
如果是增減 1 之外的數值，如 `i = i+2`，則可以用 **複合指定(compound assignment)運算子**。
```C++
int i=1;
while(i<10)
(
cout << i << endl;
i+=2; // 遞增 2
}
```
`i+=2` 就相當於 `i=i+2`。
#### 常用的複合指定運算子
|**運算子**|**範例**|**相當於**|
|:----:|:----:|:----:|
|`+=`|`i += 2`|`i = i+2`|
|`-=`|`i -= 2`|`i = i-2`|
|`*=`|`i *= 2`|`i = i*2`|
|`/=`|`i /= 2`|`i = i/2`|
|`%=`|`i %= 2`|`i = i%2`|
## 遞增、遞減運算子的評估時機
遞增運算子有兩種使用方式，如果我們要將 `變數i` 遞增 1。
* `i++`
* `++i`
以下兩個程式的執行結果相同。
###### 使用 i++
```C++
int i=1;
while(i<10)
(
cout << i << " ";
i++; // 遞增 1
}
cout << endl;
```
###### 使用 ++i
```C++
int i=1;
while(i<10)
(
cout << i << " ";
++i; // 也是遞增 1
}
cout << endl;
```
那麼 `++` 放在變數的前面和後面有什麼差別呢？主要在於 **先遞增再評估其值** 還是 **先評估其值再遞增**。
看了以下這個實例應該就很清楚了。
```C++
int i=1;
cout << i++ << endl; // 1
cout << i << endl; // 2
cout << ++i << endl; // 3
cout << i << endl; // 3
```
執行到第3行時，cout 要輸出 i++ 的值，到底是 **要先輸出i的值，再遞增i** 還是要 **先遞增i，再輸出i的值**？
因為我們把 `++` 寫在 `i` 後面，所以當下是 **先評估 i 的值給 cout，之後再遞增 i**。
而在第5行，因為因為我們把 `++` 寫在 `i` 前面，所以當下是 **先遞增 i，再評估 i 的值給 cout**。
如果牽涉到指定(assign)運算時也是一樣。
```C++
int i=1;
int a;
a = i++;
cout << a << endl; // 1
cout << i << endl; // 2
a = ++i;
cout << a << endl; // 3
cout << i << endl; // 3
```
遞減運算子的運作方式相同就不再贅述。
由於遞增遞減運算子使用在複雜的指定敘述中，很容易讓人在閱讀時搞錯評估時機和實際指定過去的值。所以建議只在很單純，絕對不會搞錯的地方使用。否則寧可用 (i+1) 或 (i-1) 這樣明確的寫法。
# 4.4 for 迴圈 while 和 do...while 迴圈很適合用在「你知道什麼條件下迴圈要繼讀或停止」，因為決定是否再繞一圈的就是一個條件判斷式。 但是在你很清楚一共要繞幾圈的情況下，使用接下來介紹的 for 迴圈，會輕鬆很多。 ## for 迴圈 使用 while 迴圈來繞指定圈數，我們多採用這樣的架構，其中變數 i 擔任計數器，我們會： 1. 指定計數器的初始值 2. 每圈檢查計數器的值是否仍符合條件 3. 每圈遞增計數器的值
1
2
3
4
5
6
7
8
9
10
###### 練習：輸出 n 的所有正因數
因為 n 的所有正因數是 1~n 之間的整數，所以我們用一個 for 迴圈來遍歷整個區間做篩選。
```C++
int n = 16;
cout << n << "的正因數有：";
for(int i=1; i<=n; i++)
{
if(n%i==0)
{
cout << " " << i;
}
}
cout << endl;
```
16的正因數有： 1 2 4 8 16
## 變數的生命週期
輸入以下這段程式後編譯執行，在編譯時期就會發生錯誤。
```C++
#include
12:25: error: 'i' was not declared in this scope
cout << "now i=" << i << endl;
^
錯誤訊息表示在 12 行那邊使用到變數 i 但是沒有宣告。但是你往上看會覺得「明明我在第7行，for 迴圈那裡一開始就宣告了啊」。
仔細看一下錯誤訊息第一行末的 - "in this scope"，他是說你沒有在這個 scope 裡宣告 i。這個 scope 是什麼意思呢？
我們來看一下這個程式：
```C++
#include
1: i=5
2: i=6
for 敘述(包含整個大括號範圍)也是一個 block scope，所以如果我們在 for 裡面宣告變數，它的生命週期也只限於該 for 迴圈內。
一般來說若只是單純用於迴圈的計數器，我們會像這樣把它宣告在 for 敘述裡。
```C++
for(int i=1; i<=5; i++) // 宣告在 for 敘述裡面
{
......
}
```
若是該變數在迴圈結束之後還有用處，我們會把它宣告在 for 迴圈的外面。
```C++
#include
1
2
3
4
5
now i=6
關於 scope 的詳細說明，有興趣的話可以先看一下這份文件 - [scope](https://en.cppreference.com/w/cpp/language/scope)。以後我們會另外開一個主題做更全面的討論。
## Online judge 讀取 n 筆測資
在競程的題目中，有一種測資型式是這樣的。
**輸入說明：**
輸入的第一行有一個整數 t。接下來的 t 行每行有一個正整數 y，代表西元年份。
**範例輸入：**
41992
1993
1900
2000
這種情形就很適合使用 for 迴圈來讀取測資。 ```C++ int n; cin >> n; for(int i=0; i
0:0
0:1
0:2
0:3
.
.
.
0:59
1:0
1:1
1:2
.
.
.
11:57
11:58
11:59
###### 練習：3x6 星號矩陣
******
******
******
---
在這個練習中，我們要輸出如上的一個 3x6 星號矩陣
看到「重覆」的部分，我們很直覺的會想用迴圈來簡化程式碼。如果只會單層迴圈，可能這樣處理。
```C++
for(int i=0; i<3; i++)
{
cout << "******" << endl;
}
```
迴圈內的 6 個星號，依然是「重覆」的狀態，所以它也可以使用迴圈來輸出。於是我們再加一個內層迴圈，讓它來輸出那 6 顆星號。
```C++
for(int i=0; i<3; i++)
{
for(int j=0; j<6; j++)
{
cout << "*";
}
cout << endl;
}
```
請注意換行的 `cout << endl;` 放在什麼位置。想想看為什麼要放在這裡，而不是放在內層迴圈裡。
在這個例子裡，使用迴圈來處理重覆的工作，同時也讓程式變得有彈性。如果今天我們要輸入任意正整數 m, n 指定的 m x n 星號矩陣，只要將 3, 6 替換成變數 m, n 即可，其他程式碼都無需更動。
###### 練習：m x n 星號矩陣
m = 2
n = 5
*****
*****
---
```C++
int m, n;
cout << "m=";
cin >> m;
cout << "n=";
cin >> n;
// 以下修改之前的雙層迴圈程式碼
for(int i=0; i
11111
22222
33333
44444
55555
———
有時候 for 敘述首行的變數不是單純只當計數器，也會參與到迴圈內的運算或輸出。所以在設計起迄數值時，我們會花點心思考量。
```C++
int n;
cin >> n;
for(int i=1; i<=n; i++) // 一共有 n 列資料要輸出。(為什麼 i 由 1~n，而非如之前用 0~n-1？)
{
for(int j=0; j
*
**
***
****
*****
———
在這個例子裡，外層迴圈的 i 除了幫外層計數，同時也是內層計數的終點值。
```C++
int n;
cin >> n;
for(int i=1; i<=n; i++) // 一共有 n 列資料要輸出。(為什麼 i 由 1~n，而非如之前用 0~n-1？)
{
for(int j=0; j
1
22
333
4444
55555
———
### 可以有的組合
多層迴圈可以由 while, do...while, for 迴圈任意組成。例如：外圈是 while，內圈是 for......等等。
至於迴圈的結構也可以有多種變化，例如以下這幾種。
型別 陣列名稱[元素數量];
其中陣列名稱的命名規則與一般變數的命名規則相同。
要特別注意的是，陣列的索引值是由 0 開紿，所以宣告大小為 10 的陣列 score。可以使用的元素是 `score[0]`~`score[9]`。
### 給定初值
如同變數可以在宣告同時給定初值，陣列也可以。
如果只宣告，但不給定初值，則陣列內各元素的值會無法預測(會是分配到的記憶體當下的值)。
```c++
int a[5] = {1, 3, 5, 7, 9};
for(int i=0; i<5; i++)
{
cout << a[i] << " ";
}
```
1 3 5 7 9
#### 初值不給足
如果陣列有 5 個元素，但是初值只給 2 個，剩下 3 個的值會是什麼？
```c++
int a[5] = {1, 3};
for(int i=0; i<5; i++)
{
cout << a[i] << " ";
}
```
1 3 0 0 0
觀察執行結果，可以發現它們被設為 0。
所以對於整數陣列，我們常用這樣的技巧來宣告並指定其初值皆為 0。
```c++
int a[5] = {0};
for(int i=0; i<5; i++)
{
cout << a[i] << " ";
}
```
0 0 0 0 0
#### 讓編譯器幫你算數量
我們可以在宣告時給初值但不指定陣列大小，編譯器會幫你算好填入。
```c++
int a[] = {1, 3, 5, 7}; // 相當於 int a[4] = {1, 3, 5, 7};
```
## 存取陣列中指定元素的值
原則上存取陣列 a 裡索引為 i 的元素值，和一般變數一樣，只要用 a[i] 來表示要存取的元素即可。
###### 練習：讀取學生成績，並接受查詢
讀取使用者輸入的 1~10 號學生成績，並接受以座號查詢其成績。輸入 0 結束程式。
---
```c++
int score[10] = {0};
for(int i=0; i<10; i++)
{
cin >> score[i];
}
while(true)
{
cout << "輸入座號查詢成績: ";
int id;
cin >> id;
if(id==0)
break;
cout << id << " 號的成績為 " << score[id-1] << endl; // 想一想，為什麼索引值是 id-1，而不是 id？
}
```
11 22 33 44 55 66 77 88 99 100
輸入座號查詢成績:3
3 號的成績為 33
輸入座號查詢成績:6
6 號的成績為 66
輸入座號查詢成績:0
因為陣列的索引值是由 0 開始編號，和我們一般生活中由 1 開紿編號的情境不同。所以也有人會選擇「浪費一個元素」來讓程式寫起來比較直覺。
```c++
int score[11] = {0}; // 宣告 11 個，索引 0 那個不用
for(int i=1; i<=10; i++) // i 由 1~10，而不是 0~9
{
cin >> score[i];
}
while(true)
{
cout << "輸入座號查詢成績: ";
int id;
cin >> id;
if(id==0)
break;
cout << id << " 號的成績為 " << score[id] << endl; // id 不用減 1 了
}
```
## 陣列大小在宣告後無法改變
陣列大小在宣告後無法改變，所以通常我們會宣告「足夠」的大小。例如：在班級成績儲存時，若班級人數不超過 50 人，我們會宣告大小為 50 的陣列。
###### 練習：讀取學生成績，並接受查詢(n 人版)
讀取使用者輸入的 1~n 號學生成績，並接受以座號查詢其成績。輸入 0 結束程式。
班級人數不超過 50 人。
**輸入說明：**
* 輸入的第一行為正整數 n，表示接下來有 n 個整數，分別代表 1~n 號學生的成績。
---
```c++
int score[50] = {0}; // 足夠的大小
int n;
cin >> n;
for(int i=0; i
string 不是 int, float, double, char ...這種原生資料型別(Primitive Data Types)。他是用 C++ 寫出的一個類別(class)，所以擁有比原生資料型別更多的能力。
### 取得 string 字串長度 使用 string 的 `length()` 方法(method)，可以取得 string 內儲存字串的長度。 ```C++ string str; str = "abc"; cout << str.length() << endl; // 3 cin >> str; // 輸入 Memory cout << str.length() << endl; // 6 ``` ###### 練習：Reverse output - 反向輸出字串 讀取一個不含空白字元的字串，反向輸出它。 **範例輸入：** Hello **範例輸出：** olleH --- 要反向輸出字串，我們需要知道該宇串的長度，才能使用索引值，將它一個一個字元反向輸出。 ```C++ #include
Hello
olleH
###### 練習：Reverse a string - 反向一個字串
讀取一個不含空白字元的字串，**真的將其內容反向** 後再輸出。
**範例輸入：**
Hello
**範例輸出：**
olleH
---
上網查一下 ASCII，看看每個英文字元對應的編碼數值為何。 https://zh.wikipedia.org/zh-tw/ASCII
仔細觀察一下，大寫字母的字碼加上 32 就是小寫字母的字碼。 A|B|C|D|E|F|...|W|X|Y|Z| -|-|-|-|-|-|-|-|-|-|-| 65|66|67|68|69|70|...|87|88|89|90| a|b|c|d|e|f|...|w|x|y|z| -|-|-|-|-|-|-|-|-|-|-| 97|98|99|100|101|102|...|119|120|121|122| ### 大小寫轉換 ###### 練習：to lower - 把英文單字轉換成全部小寫 讀取一個不含空白字元的字串，將其中的大寫字母都改成小寫。 **範例輸入：** YouTube **範例輸出：** youtube --- ```C++ #include
YouTube
Before reverse: [YouTube]
After reverse: [youtube]
大家可以自己試試看
* 全部轉大寫
* 大寫小寫互換
### char <--> int
既然字串裡的字元，其實都是以數值方式儲存在記憶體中。如果我們想把字串 "abcdefg" 的字碼像這樣依序列出。
97 98 99 100 101 102 103
是不是這樣就可以了？
```C++
string str = "abcdefg";
for(int i=0; i
abcdefg
## 讀取一整行
在之前的例子中，我們無法輸入 "This is a test." 這樣的句子。因為 cin 在讀取 "This" 之後遇到空白字元，就中斷讀取。也就是一次只能讀進一個單字。
我們試一下這個程式
```C++
#include Hello world!
This is a test.
我們得到的輸出會是
1: Hello
2: world!
3: This
4: is
5: a
6: test.
### 使用 getline 讀取一行
使用 `getline()` 函數可以讀入一整行的字串，也就是讀到換行為止。
```C++
#include
1: Hello world!
2: This is a test.
### cin 和 getline 搭配使用會遇到的問題
如果題目的輸入是這樣，第一行是 3 表示接下來有 3 行字串。
3
Hello, world.
This is a test.
Good morning
使用以下的程式讀取後，依序輸出各行字串。
```C++
#include
Hello, world.
This is a test.
前面多一行空白行，後面少一行 "Good morning"
原因如下：
* 我們的輸入包含按下的[Enter]是長這個樣子
3`\n`Hello, world.`\n`This is a test.`\n`Good morning`\n`
* 第 10 行的 cin >> n; 會把 3 讀進 n，於是剩下
`\n`Hello, world.`\n`This is a test.`\n`Good morning`\n`
* 接下來第 14 行的 getline(cin, line); 會把一行字串讀入 line 中，但是因為一開始就遇到換行，於是 line 裡面是個空字串 ""。但迴圈已繞了一圈，現在剩下的是
Hello, world.`\n`This is a test.`\n`Good morning`\n`
* 所以接下來第二圈的 getline 讀完一行後，剩下
This is a test.`\n`Good morning`\n`
* 最後一圈的 getline 讀完一行後，還剩下
Good morning`\n` 沒被讀取，也沒被印出。
解決的方式是，用 cin 讀完 3 這個整數後，想辦法把後面的換行字元 '\n' 也先讀取掉。
```C++
#include 
1 2 3 4 5 6
5 12 7 11 9 8
10 21 13 22 23 16
4 78 13 45 51 11
###### 練習：2D 地圖
給定一張 m x n 大小的地圖，以及各地貌的代表數字，請輸出該地圖。
$ 1 \le m, n \le 100 $
**輸入說明:**
第一行是兩個正整數 m n，表示陣列的 列數(row)、行數(column)。
接下來是共 m 列，每列有 n 個整數的地圖資訊，表示該位置的地貌代碼。
接著是一個整數 k，表示有 k 種地貌。
最後是 k 列，每列為一個整數 i 與一個字元 c，表示代碼 i 的地貌為 c。
**輸出說明:**
輸出該地圖的地貌，如範例輸出。
**範例輸入:**
3 4
1 1 1 1
2 2 0 1
1 2 0 1
3
0 _
1 #
2 *
**範例輸出:**
####
**_#
#*_#
---
```C++
#include 
平常我們很少使用超過 3 維的陣列，除非你很確定自己需要，否則在你宣告一個大於 3 維的陣列之前，可以想一想，有沒有更好的方式可以不要用到這麼高維的陣列。
# 06-函數
# 6-1 函數
隨著寫程式經驗愈來愈多，你會發現有些程式碼會不斷重複出現，就像例行性工作一樣，例如：求平方根、將資料排序、驗證帳號密碼......等等。一次又一次的輸入這些程式碼會讓人很不耐煩。對於這些經常出現的程式碼片段，我們可以使用函數來把它們包裝起來。C/C++裡面的函數就像數學裡面的函數，例如：
$f(x)=2x^2+3x+4$
它有一個輸入：x，有一個輸出：f(x)。你給它一個輸入 3，它在運算後會給你一個輸出31；你給它另一個輸入 2，它會給你另一個相應的輸出18。不管你給的輸入是什麼，它都會很忠實的去完成該做的事 $2x^2 + 3x + 4$ ，並把結果輸出給你。
## 定義函數
以上面那個 f(x) 為例，我們可以這樣在 C++ 裡定義它。
```C++
int f(int x)
{
int result = 2*x*x +3*x + 4;
return result;
}
```
其架構如下：
main.cpp: In function 'int main()':
main.cpp:11:11: error: 'f' was not declared in this scope
ans = f(n);
^
## 宣告函數
有沒有注意到，前面我們一直說定義函數，而不是宣告函數(declare)。
我們以同一個 函數f 為例，宣告這個函數的作法為：
```C++
int f(int x);
```
或
```C++
int f(x);
```
宣告函數只要講清楚這幾個重點即可：
1. 函數名稱
2. 參數列 (每個參數的型別，可以沒有名字)
3. 回傳值型別
我們把上面的範例程式改成只有宣告試試。
```C++
#include
main.cpp:13: undefined reference to `f(int)'
main.cpp:16: undefined reference to `f(int)'
main.cpp:20: undefined referenc
這個 `undefined reference to 'f(int)'` 是什麼意思呢？
我們的程式碼要經過「編譯(compile)」、「連結(link)」兩個步驟，才能生成最終的可執行檔。
在編譯階段，編譯器看到叫用(call)函數時，只會確認之前宣告過的函數
1. 名稱是否相符
2. 參數列的數量和型別是否相符
3. 回傳值型別是否相符
如果都符合，會在叫用函數的地方留個「空位」，然後編譯將會成功完成，進入連結階段。
在連結階段必須真的有一個函數被定義過，才能把這個函數「身體」所在的位置填入之前編譯階段留下的「空格」。
我們修改程式，在末端補上 函數f 的定義，即可順利建置。
```C++
#include
回傳 2 整數中的最小值
2
回傳 2 浮點數中的最小值
2.1
回傳 3 整數中的最小值
2
## 在函數中叫用函數
在前例中我們為了求 3 整數中的最小數，又另外寫了一個 3 參數的 MIN 函數，其內容也是整個重寫。
我們的另一種選擇是利用已寫好的 2 參數 MIN 函數，來實作出 3 參數的 MIN 函數。
```C++
#include
Step 1:
回傳 2 整數中的最小值
2
Step 2:
回傳 3 整數中的最小值
回傳 2 整數中的最小值
回傳 2 整數中的最小值
2
Step 3:
回傳 2 整數中的最小值
回傳 2 整數中的最小值
2
###### 練習：求 a, b 兩正整數的最大公因數(GCD)
設計一個 GCD 函數，求 2 正整數的最大公因數。
---
**1. 用迴圈慢慢找**
```C++
int GCD(int a, int b)
{
if(a>b)
swap(a, b);
int ans = 1;
for(int i=1; i<=a; i++) {
if(a%i==0 && b%i==0) {
ans = i;
}
}
return ans;
}
```
**2. 超級快的「輾轉相除法」**
```C++
int GCD(int a, int b)
{
int r;
while(a%b>0) {
r = a%b;
a = b;
b = r;
}
return b;
}
```
###### 練習：求 a, b 兩正整數的最小公倍數(LCM)
設計一個 LCM 函數，求 2 正整數的最小公倍數。
---
**利用之前的 GCD 函數**
```C++
int LCM(int a, int b)
{
return a/GCD(a, b)*b;
}
```
我們不使用 `a*b/GCD(a,b)` 的原因是，若先把 a*b ，其相乘後數值溢位的可能性更大，先把 a 除以兩數的公因數，再乘上 b，可以減低溢位的風險。
# 6-3 傳值呼叫 與 傳參考呼叫
## 參數與引數
在提到函數與呼叫使用函數時，我們會用到 **參數(parameter)** 和 **引數(argument)** 這兩個名詞。
我們可以簡單的用這張圖來區分他們。
* **參數(parameter)** 是在定義函數時，用來承接傳入資料的變數。
* **引數(argument)** 是在呼叫使用函數時，傳入的資料。
I have ticket No.1
I have ticket No.2
I have ticket No.3
---
使用這種方式沒什麼問題，但是每次都要傳遞變數 num。如果想避免這個麻煩，可以使用全域變數，也就是把 num 宣告在所有函數(包含 main)的外面。
###### 練習：抽號碼牌(2)
```C++
#include
I have ticket No.1
I have ticket No.2
I have ticket No.3
---
使用全域變數雖然很方便，但是它有一個極大的缺點，就是大家都可以動到它。
有時候你會很納悶，明明我沒動它，它的值怎麼變了。找了半天才發現在某個不起眼角落或函數裡的程式碼動到它的值。
## 函數裡的靜態變數(static variable)
一般來說宣告在函數裡的變數都是區域變數(local variable)，一但離開函數後就會消滅，下次被呼叫時才會重新產生出來。
但是如果在宣告時，在前面加上 `static` 修飾詞，它就會是個靜態變數，在離開函數時變數會記得當下的值，不會消滅。下次函數被呼叫時，它依然活著不會被重新產生和給定初值。
###### 練習：抽號碼牌(3)
```C++
#include
I have ticket No.1
I have ticket No.2
I have ticket No.3
---
在某些情況下，靜態變數是很好用的！
# 07-指標
# 7-1 指標(pointer)
## 記憶體-位址
當宣告一個變數並賦予它初值後，我們可以確定這個值一定存放在電腦記憶體的某個地方，問題是它到底放在哪裡呢 ? 在地球表面上我們可以用經緯度來標定一個位置，而在電腦裡要標定記憶體中的某個位置則是要靠「位址(address)」
0x22ff18
0x22ff14
## 指標變數
在 C/C++ 中用來儲存位址的是一種特殊型別的變數－指標(pointer)變數
### 宣告
```C++
資料型別 *變數名稱; // 注意前面有個 * 號
```
### 範例
```C++
int *pNumber; // 宣告一個名為 pNumber 的指標變數，用來指向一個 int 型別的變數
float *pF = nullptr; // 宣告一個名為 pF 的指標變數，用來指向一個 float 型別的變數，
//並給定指標的初值為 nullptr，即不指向任何地方的空指標。
```
### 取址(address-of)運算子 &
在變數名稱前加上一個取址運算子(&)可以取得該變數的位址。
```C++
int a = 6;
int *pA = nullptr;
pA = &a; // 取得變數 a 的位址並儲存在指標 pA 中
```
### 提領(dereference)運算子 *
在指標變數名稱前加上一個提領運算子 *， 可以 讀/寫 它所指向變數的值。
```C++
int a = 6, b = 5;
int *pNum = nullptr;
pNum = &a;
cout << *pNum << endl;
pNum = &b;
cout << *pNum << endl;
```
6
5
---
```C++
int a = 6, b = 5;
int *pNum = nullptr;
cout << "a = " << a << ", b = " << b << endl;
pNum = &a;
*pNum = 5;
pNum = &b;
*pNum = 6;
cout << "a = " << a << ", b = " << b << endl;
```
a = 6, b = 5
a = 5, b = 6
---
```C++
int a = 6, b = 5;
int *pNum1 = nullptr;
int *pNum2 = nullptr;
cout << "a = " << a << ", b = " << b << endl;
pNum1 = &a;
pNum2 = pNum1;
*pNum2 = 3;
cout << "a = " << a << ", b = " << b << endl;
```
a = 6, b = 5
a = 3, b = 5
## 動態配置記憶體
截至目前為止，我們的程式都在一開始就將需要使用的記憶體（如：變數、陣列）大小寫死在程式碼中。
```C++
int a = 0, b = 0; // 兩個 int 變數，共 2*4=8 byte
int score[50]; // 一個包含 50 個 int 的陣列，共 50*4=200 byte
```
但是有時候我們在寫程式時並不知道使用者執行時需要多大的空間。例如我們要寫一個讀入學生成績並依成績高低排序的程式，你可能會想這樣寫：
```C++
int numOfStd=0;
int score[50];
cout << "請輸入學生人數：";
cin >> numOfStd;
for(int i=0; i
Name: Alice
Age: 18
---
## 5. 初始化（給定初值）
除了先宣告再指定值，也可以在建立時直接初始化。
```c++
Person p1 = {"Bob", 20};
```
這相當於：
- `p1.name = "Bob"`
- `p1.age = 20`
```c++
Person p2 = {"Cindy", 22};
cout << p2.name << ", " << p2.age << endl;
```
---
## 6. struct 用於函數的參數
你可以把整個 `struct` 傳進函式，讓程式更清楚。
```c++
#include **注意**：對空的 vector 呼叫 pop_back() 是未定義行為（UB），請先確認 !v.empty()。
### 5. 存取元素 #### 下標運算子 `[]` ```c++ vectorv.size() 回傳型別為 size_t（無號整數），若用 int i = v.size() - 1 倒著走時要小心，空 vector 的 0 - 1 會變成一個很大的數。
### 2. 方法二：Range-based for（範圍式 for） C++11 起支援，最簡潔： ```c++ // 唯讀走訪 for (int x : v) { cout << x << " "; } // 修改元素（加上 &） for (int& x : v) { x *= 2; // 每個元素乘以 2 } ``` ### 3. 方法三：迭代器（Iterator） 迭代器的概念類似**指標**，這也是為什麼熟悉指標的你能很快上手。 #### 圖解：迭代器與指標的對比 ``` 傳統陣列指標： int arr[] = {10, 20, 30}; int* ptr = arr; // ptr 指向第一個元素 ┌────┬────┬────┐ │ 10 │ 20 │ 30 │ └────┴────┴────┘ ↑ ptr ptr++; // 指向下一個 *(ptr) = 99; // 解參考後修改 vector 迭代器： vector實務建議：平常用 range-based for，需要插入/刪除時用迭代器，需要索引時用下標。
# 9-4 常用成員函數 ## 其他常用成員函數 ### 1. front() 與 back() ```c++ vectorinsert() 後，原本的迭代器可能**失效**，請重新取得。
### 3. erase()：移除指定位置的元素 ```c++ vector注意：二維 vector 的每一列長度可以不同（鋸齒狀陣列），這與傳統二維陣列不同。
# 9-5 實作練習 ### 練習一：成績管理系統（基礎操作） **題目敘述** 請你撰寫一個程式，功能如下： 1. 讀入 N 筆學生成績（整數，0~100） 2. 輸出所有成績 3. 輸出最高分、最低分、平均分數（取到小數點後兩位） 4. 刪除最後一筆成績後，再輸出一次所有成績 **範例輸入** ``` 5 90 75 88 62 95 ``` **範例輸出** ``` 成績：90 75 88 62 95 最高分：95 最低分：62 平均：82.00 刪除最後一筆後：90 75 88 62 ``` **提示** - 使用 `push_back` 加入一筆成績 - 善用 `size()`、`pop_back()`參考解答（請先自己嘗試！）
```c++ #include參考解答（請先自己嘗試！）
```c++ #include參考解答（請先自己嘗試！）
```c++ #include
Name: Alice, Age: 20
不使用 this
Name: , Age: -103249728
# 10-2 存取控制——public 與 private
## 一、class 裡的東西，不是誰都可以動的
先看一個銀行帳戶的例子。
```c++
#include 
[票券] 星際大戰 | 座位 12 | 票價 280 元 | 狀態：未使用
[票券] 未命名 | 座位 0 | 票價 0 元 | 狀態：未使用
入場成功！電影：星際大戰，座位：12
此票券已使用過！
票價不能為負數！
星際大戰 目前票價：250 元
[票券] 星際大戰 | 座位 12 | 票價 250 元 | 狀態：已使用
---
## 練習二：水壺（`Pitcher`）
### 情境說明
你設計一個登山水壺管理程式。每個水壺有名稱、最大容量和目前水量。注水時若超過容量會溢出；倒水時若水量不足則失敗；容量不能設得比目前水量還小。
---
### 規格列表
#### 成員變數（皆為 `private`）
| 變數名稱 | 型態 | 說明 |
|---|---|---|
| `name` | `string` | 水壺名稱 |
| `capacity` | `int` | 最大容量（ml） |
| `current` | `int` | 目前水量（ml） |
#### 建構子
| 建構子 | 初始值 |
|---|---|
| `Pitcher()` | `name="水壺"`、`capacity=1000`、`current=0` |
| `Pitcher(string name, int capacity)` | 依參數設定，`current=0` |
#### Getter（皆加 `const`）
| 函式 | 回傳型態 | 說明 |
|---|---|---|
| `getName()` | `string` | 回傳水壺名稱 |
| `getCapacity()` | `int` | 回傳最大容量 |
| `getCurrent()` | `int` | 回傳目前水量 |
#### Setter（含驗證）
| 函式 | 驗證規則 |
|---|---|
| `setCapacity(int capacity)` | `≤ 0` 印出 `"容量必須大於 0！"`；新容量 `< current` 印出 `"新容量小於目前水量，無法設定！"` |
#### 其他成員函式
| 函式 | 回傳 | 說明 |
|---|---|---|
| `fill(int amount)` | `void` | 注水；若超出容量則補滿並印出溢出量，否則正常注水 |
| `pour(int amount)` | `bool` | 倒水；水量不足回傳 `false` 並印出提示，否則正常倒出回傳 `true` |
| `status() const` | `void` | 印出水壺狀態，含百分比（格式見預期輸出） |
---
### `main()`
```cpp
int main() {
Pitcher p1("運動水壺", 750);
Pitcher p2;
p1.status();
p2.status();
p1.fill(500);
p1.fill(400); // 會溢出
p1.pour(200);
p1.pour(600); // 水量不足
p1.setCapacity(-1); // 非法
p1.setCapacity(100);// 非法（小於目前水量 550）
cout << p1.getName() << " 容量：" << p1.getCapacity() << " ml" << endl;
p1.status();
}
```
### 預期輸出
[運動水壺] 0 / 750 ml（0%）
[水壺] 0 / 1000 ml（0%）
運動水壺 注入 500 ml。
運動水壺 已裝滿，多餘 150 ml 溢出。
運動水壺 倒出 200 ml。
運動水壺 水量不足，無法倒出 600 ml！
容量必須大於 0！
新容量小於目前水量，無法設定！
運動水壺 容量：750 ml
[運動水壺] 550 / 750 ml（73%）
---
## 練習三：遊戲計分板（`ScoreBoard`）
### 情境說明
你正在設計一款小遊戲的計分系統。計分板記錄玩家名稱、歷史最高分、當前分數和剩餘生命數。每次得分若超過歷史最高分則更新紀錄；失去所有生命時宣告遊戲結束；重新開始時分數歸零但最高分保留。
---
### 規格列表
#### 成員變數（皆為 `private`）
| 變數名稱 | 型態 | 說明 |
|---|---|---|
| `playerName` | `string` | 玩家名稱 |
| `highScore` | `int` | 歷史最高分 |
| `currentScore` | `int` | 當前分數 |
| `lives` | `int` | 剩餘生命數 |
#### 建構子
| 建構子 | 初始值 |
|---|---|
| `ScoreBoard()` | `playerName="玩家"`、`highScore=0`、`currentScore=0`、`lives=3` |
| `ScoreBoard(string playerName, int lives)` | 依參數設定，`highScore=0`、`currentScore=0` |
#### Getter（皆加 `const`）
| 函式 | 回傳型態 | 說明 |
|---|---|---|
| `getPlayerName()` | `string` | 回傳玩家名稱 |
| `getHighScore()` | `int` | 回傳歷史最高分 |
| `getCurrentScore()` | `int` | 回傳當前分數 |
| `getLives()` | `int` | 回傳剩餘生命數 |
#### Setter（含驗證）
| 函式 | 驗證規則 |
|---|---|
| `setPlayerName(string playerName)` | 名稱為空字串時印出 `"玩家名稱不能為空！"` 並放棄修改 |
#### 其他成員函式
| 函式 | 回傳 | 說明 |
|---|---|---|
| `addScore(int points)` | `void` | 加分（`≤0` 印出提示拒絕）；若 `currentScore > highScore` 則更新並印出新紀錄訊息 |
| `loseLife()` | `bool` | 扣一條命；`lives=0` 時印出遊戲結束訊息並回傳 `false`，否則回傳 `true` |
| `reset()` | `void` | `currentScore` 歸零、`lives` 回復 3，`highScore` 保留，印出提示 |
| `print() const` | `void` | 印出所有資訊（格式見預期輸出） |
---
### `main()`
```cpp
int main() {
ScoreBoard sb("小明", 3);
ScoreBoard sb2;
sb.print();
sb2.print();
sb.addScore(100);
sb.addScore(250);
sb.addScore(50);
sb.loseLife();
sb.loseLife();
sb.loseLife(); // 第三條命，遊戲結束
sb.setPlayerName(""); // 非法
sb.setPlayerName("小明Pro");
sb.reset();
sb.print();
sb.addScore(500); // 超越舊最高分
sb.print();
}
```
### 預期輸出
== 小明 == 當前：0 | 最高：0 | 命：3
== 玩家 == 當前：0 | 最高：0 | 命：3
新紀錄！最高分更新為 100
小明 得 100 分，目前：100
新紀錄！最高分更新為 350
小明 得 250 分，目前：350
新紀錄！最高分更新為 400
小明 得 50 分，目前：400
小明 失去一條命，剩餘：2
小明 失去一條命，剩餘：1
小明 失去一條命，剩餘：0
遊戲結束！小明 最終得分：400
玩家名稱不能為空！
小明Pro 重新開始，最高分保留：400
== 小明Pro == 當前：0 | 最高：400 | 命：3
新紀錄！最高分更新為 500
小明Pro 得 500 分，目前：500
== 小明Pro == 當前：500 | 最高：500 | 命：3
# 11-自己實作一個 vector 類別
# 11-1 規劃我們的 Vec 類別
## 一、Vec 類別需要什麼？
在這個章節裡，我們嘗試自己建立一個簡單版的 vector，一個叫做 Vec 的類別。
我們至少需要以下三項屬性：
1. `data`: 指向一塊儲存資料的記憶體空間
2. `size`: 記錄目前 Vec 裡的元素數量
3. `capacity`: 記錄目前 Vec 裡己向作業系統要求配置的空間大小
Cap:1 Size:1
Cap:2 Size:2
Cap:4 Size:3
Cap:4 Size:4
Cap:8 Size:5
# 11-4 重載 [] 運算子
現在我們還缺一個重要的功能，那就是存取 Vec 裡的值。
試著執行這段程式看看。
**[main.cpp]**
```C++
#include