中華大學國貿系教學規範

Transcription

1 中 華 大 學 97 學 年 度 基 礎 課 程 教 學 提 升 計 畫 程 式 設 計 - 講 義 課 程 召 集 人 : 資 訊 工 程 學 系 張 欽 智 課 程 講 義 及 題 庫 編 撰 教 師 : 資 訊 管 理 學 系 應 鳴 雄 資 訊 工 程 學 系 張 欽 智 中 華 民 國 九 十 八 年 七 月 I

2 目 錄 壹 課 程 講 義... 1 單 元 1:C/C++ 語 言 基 礎 簡 介... 1 單 元 2: 基 本 資 料 型 態 與 算 術 運 算 單 元... 6 單 元 3: 格 式 化 輸 入 與 輸 出 單 元 4: 選 擇 敘 述 結 構 單 元 5: 反 覆 敘 述 結 構 單 元 6: 函 式 單 元 7: 陣 列 單 元 8: 指 標 單 元 9: 字 元 與 字 串 單 元 10: 檔 案 導 向 輸 入 與 輸 出 單 元 11: 結 構 與 其 他 資 料 型 態 單 元 12: 遞 迴 單 元 13: 物 件 概 念 單 元 14: 類 別 單 元 15: 資 料 抽 象 化 單 元 16: 運 算 子 多 載 單 元 17: 繼 承 單 元 18: 虛 擬 函 數 與 多 型 單 元 19: 串 流 輸 入 / 串 流 輸 出 單 元 20: 樣 版 單 元 21: 例 外 處 理 貳 參 考 資 料 I

3 壹 課 程 講 義 單 元 1: C/C++ 語 言 基 礎 簡 介 (Unit 1: Fundamentals of the C/C++ Programming Language) 一 程 式 語 言 簡 介 以 下 針 對 程 式 軟 體 及 程 式 設 計 之 基 本 概 念 進 行 介 紹 ( 一 ) 程 式 程 式 (Programs) 是 使 用 指 定 程 式 語 言 所 撰 寫 沒 有 混 淆 文 字 數 值 和 鍵 盤 符 號 所 組 成 的 特 殊 符 號, 這 些 符 號 組 合 成 指 令 和 敘 述, 再 進 一 步 編 寫 成 程 式 碼, 程 式 碼 可 以 告 訴 電 腦 解 決 指 定 問 題 的 步 驟 程 式 如 同 一 個 轉 換 器, 當 從 電 腦 鍵 盤 或 滑 鼠 取 得 輸 入 資 料 後, 執 行 程 式 就 可 以 將 資 料 轉 換 成 有 用 的 資 訊 換 句 話 說, 為 了 讓 電 腦 能 夠 看 懂 程 式, 程 式 需 要 依 據 程 式 語 言 的 規 則 結 構 和 語 法, 以 指 定 的 文 字 或 符 號 來 撰 寫 程 式, 例 如 :C++ 程 式 語 言 撰 寫 的 程 式 稱 為 原 始 碼 (Source Code) ( 二 ) 軟 體 軟 體 (Softwares) 是 一 種 電 腦 執 行 的 應 用 程 式, 通 常 軟 體 是 一 個 或 多 個 程 式 的 泛 稱, 或 是 一 整 套 應 用 程 式 的 總 稱, 應 用 程 式 (Applications) 是 一 種 處 理 指 定 工 作 的 電 腦 程 式, 例 如 : 數 學 分 析 文 書 處 理 詴 算 表 和 程 式 語 言 開 發 工 具 等 ( 三 ) 程 式 設 計 的 流 程 程 式 設 計 的 流 程 可 以 簡 單 劃 分 為 以 下 五 個 步 驟 : 1.Defining the program: 定 義 問 題 2.Planning the solution: 設 計 解 決 方 案 ( 演 算 法 ) 3.Coding the program: 撰 寫 程 式 4.Testing the program: 測 詴 程 式 5.Documenting the program: 撰 寫 程 式 發 展 文 件 ( 四 ) 程 式 語 言 的 分 類 目 前 電 腦 的 程 式 語 言 相 當 多, 程 式 語 言 隨 著 電 腦 科 技 的 進 步, 已 經 延 伸 出 龐 大 的 族 群, 在 程 式 語 言 的 分 類 上, 以 發 展 的 世 代 來 分, 如 下 表 所 示 : 1. 機 器 語 言 (Machine Language): 指 硬 體 內 部 所 使 用 的 語 言, 也 是 電 腦 唯 一 能 直 接 辨 識 的 語 言, 通 常 是 一 連 串 的 數 字 所 組 成 (0 或 1) 2. 組 合 語 言 (Assembly Language): 最 接 近 機 器 語 言 的 一 種 低 階 語 言, 屬 於 符 號 式 語 言 組 合 語 言 必 頇 經 由 組 譯 器 (assembler) 轉 換 成 機 器 語 言, 才 能 在 電 腦 上 執 行 3. 高 階 語 言 (High-level Language): 又 稱 編 譯 語 言, 其 文 法 接 近 日 常 英 文 用 語, 也 包 含 一 般 常 用 的 數 學 運 算 符 號 高 階 語 言 的 原 始 程 式 碼 必 頇 轉 換 為 機 器 語 言 才 能 正 確 執 行 轉 換 程 式 包 含 直 譯 器 和 編 譯 器 兩 種 4. 非 常 高 階 語 言 (Very High-level Language): 又 稱 第 四 代 語 言, 如 SQL (Structual Quary Language, 結 構 化 查 詢 語 言 ) 5. 自 然 語 言 (Natural Language) 另 外 程 式 語 言 也 常 以 低 階 語 言 與 高 階 語 言 加 以 區 分 : 1. 低 階 語 言 (Low Level Languages): 低 階 語 言 是 一 種 偏 向 電 腦 容 易 了 解 的 程 式 語 言, 屬 於 電 腦 看 的 懂 的 程 式 語 言, 程 式 執 行 效 率 高, 但 是 使 用 者 不 易 學 習 2. 高 階 語 言 (High Level Languages): 高 階 語 言 是 一 種 接 近 人 類 語 言 的 程 式 語 言, 可 以 說 是 1

4 一 種 半 英 文 (Half-english) 語 言, 因 為 電 腦 不 能 馬 上 看 的 懂, 需 要 進 一 步 使 用 程 式 進 行 翻 譯, 在 轉 換 成 機 器 語 言 後, 因 為 轉 換 出 來 的 程 式 碼 通 常 比 直 接 使 用 機 器 語 言 撰 寫 的 冗 長, 所 以 效 率 較 低, 但 是 非 常 適 合 使 用 者 學 習 ( 五 ) 直 譯 器 與 編 譯 器 的 比 較 目 前 常 見 的 高 階 語 言 有 Java C/C++ C# FORTRAN COBOL Pascal BASIC 和 Borland Delphi 等, 高 階 語 言 需 要 進 行 翻 譯, 將 程 式 碼 轉 譯 成 機 器 語 言 的 執 行 檔 案 後, 才 能 在 電 腦 上 執 行, 翻 譯 的 方 式 分 為 兩 種, 如 下 所 示 : 類 型 說 明 優 點 缺 點 舉 例 直 譯 器 Interpreter 編 譯 器 Compiler 將 原 始 程 式 的 指 令 逐 一 翻 譯 並 執 行, 不 需 要 經 過 編 譯 將 原 始 程 式 編 譯 後, 先 產 生 目 的 檔 (.obj), 再 將 其 他 要 連 結 的 程 式 連 結 後, 再 執 行 該 程 式 因 此, 其 主 要 功 能 在 於 : 1. 檢 查 程 式 碼 的 錯 誤 2. 將 程 式 碼 翻 譯 成 機 器 語 言 的 程 式 碼 檔 案 佔 用 的 記 憶 體 較 少 修 改 及 除 錯 容 易 執 行 時 不 需 要 重 複 編 譯, 執 行 速 度 及 效 率 高 每 次 執 行 前 才 翻 譯, 執 行 速 度 慢 效 率 較 低 原 始 程 式 經 過 修 改 就 必 頇 重 新 編 譯 較 佔 用 記 憶 體 空 間 BASIC(BASICA QuickBasic 等 ) HTML( 含 VBScript 和 JavaScrip) C/C++ Java COBOL PASCAL ( 六 ) 依 程 式 設 計 的 方 式 分 類 1. 程 序 導 向 程 式 設 計 (Procedure-Oriented Programming) 2. 物 件 導 向 程 式 設 計 (Object-Oriented Programming): 如 :C++,Java,Visual BASIC ( 七 ) 常 見 的 高 階 程 式 語 言 語 言 說 明 應 用 FORTRAN FORmula TRANslator (1954) 科 學 COBOL COmmon Business-Oriented Language (1959) 商 業 BASIC Beginner's All-purpose Symbolic Instruction Code 教 育, 商 業 Pascal named after French inventor Blaise Pascal (1971) 教 育, 系 統, 科 學 Ada named after Ada, the Countess of Lovelace (1980) 軍 事, 一 般 C evolved from the language B, from Bell Labs (1972) 系 統, 一 般 2

5 二 C 語 言 簡 介 ( 一 ) 歷 史 發 展 C 語 言 是 由 美 國 貝 爾 實 驗 室 (Bell Laboratory) 的 Dennis Ritchie 在 1972 年 所 發 展 出 來 的 C 語 言 的 前 身 是 B 語 言, 原 先 用 在 DEC PDP-11 電 腦 上 C 語 言 在 各 種 帄 台 上 快 速 發 展, 之 後 出 了 許 多 版 本, 為 了 統 一 各 版 本, 美 國 國 家 標 準 局 (ANSI) 提 出 了 一 套 標 準, 並 在 1989 年 通 過 審 查, 而 在 1999 年 則 進 行 了 修 訂 ( 二 )C/C++ 程 式 的 開 發 環 境 C/C++ 程 式 在 執 行 前 需 經 過 以 下 六 個 階 段 : 1. 編 輯 : 使 用 者 可 利 用 文 書 編 輯 器 (editor) 撰 寫 或 修 改 C 程 式 碼 (source code) 2. 前 置 處 理 : 前 置 處 理 器 (preprocessor) 會 在 開 始 編 譯 前 自 動 執 行, 依 據 程 式 碼 中 # 所 標 示 的 指 示 (preprocessor directives), 進 行 代 換 或 插 入 等 動 作 例 如 :#include <stdio.h> 告 訴 編 譯 器 在 未 編 譯 程 式 之 前, 先 將 程 式 庫 中 的 標 頭 檔 stdio.h 插 入 該 位 置 3. 編 譯 : 編 譯 器 (compiler) 將 程 式 碼 編 譯 為 目 的 碼 (object code) 4. 連 結 : 連 結 器 (linker) 將 一 個 或 多 個 目 的 檔 (.obj) 與 靜 態 程 式 庫 檔 (.lib) 連 結, 產 生 可 執 行 檔 (.exe) 5. 載 入 : 載 入 器 (loader) 將 可 執 行 檔 (.exe) 載 入 記 憶 體, 並 與 動 態 程 式 庫 檔 (.dll) 連 結 動 態 程 式 庫 可 減 少 執 行 檔 所 佔 的 硬 碟 和 記 憶 體 空 間 6. 執 行 : 最 後, 電 腦 在 CPU 的 控 制 下, 開 始 執 行 所 載 入 的 程 式 編 輯 edit.c.cpp 前 置 處 理 preprocess 編 譯 compile.obj 連 結 link.exe 載 入 load 執 行 execute 標 頭 檔.h 其 他.obj.lib.dll 三 繪 製 流 程 圖 開 始 決 策 預 定 函 數 的 執 行 設 定 / 程 序 結 束 3

6 四 結 構 化 程 式 設 計 結 構 化 程 式 設 計 是 一 種 組 織 和 撰 寫 程 式 碼 的 技 術, 使 用 由 上 而 下 的 設 計 方 法 (Top-down Design) 來 分 析 問 題, 將 程 式 分 解 成 階 層 架 構 的 模 組 (Modules), 每 個 模 組 是 一 段 擁 有 獨 立 功 能 的 程 式 碼, 而 且 只 有 單 一 的 進 入 點 和 離 開 點, 各 模 組 間 使 用 3 種 流 程 控 制 來 整 合 : 循 序 結 構 (Sequential) 選 擇 結 構 (Selection) 和 重 複 結 構 (Iteration) 總 結 結 構 化 程 式 設 計 的 主 要 觀 念 有 3 項, 如 下 所 示 : 1. 由 上 而 下 的 設 計 方 法 2. 流 程 控 制 結 構 3. 模 組 (Modules) 類 型 說 明 語 法 流 程 圖 循 序 結 構 (Sequence Structure) 循 序 結 構 是 程 式 預 設 的 執 行 方 式, 程 式 是 一 個 程 式 敘 述 接 著 一 個 敘 述 依 序 的 執 行 開 始 敘 述 1 敘 述 2 選 擇 結 構 (Selection Structure) 選 擇 結 構 是 一 種 條 件 控 制 敘 述, 它 可 以 分 為 單 一 選 擇 二 選 一 或 多 選 一 3 種, 程 式 執 行 的 順 序 是 依 照 關 係 判 斷 運 算 式 的 條 件, 來 決 定 執 行 哪 一 個 程 式 區 塊 的 程 式 碼 if else switch case 判 斷 敘 述 2 false true 敘 述 1 重 複 結 構 (Iteration Structure) 重 複 結 構 是 一 種 迴 圈 控 制, 它 是 重 複 執 行 一 個 程 式 區 塊 的 程 式 碼, 提 供 一 個 結 束 條 件 結 束 迴 圈 的 執 行, 依 據 結 束 條 件 測 詴 的 位 置 不 同 分 為 兩 種 : 1. 前 測 式 重 複 結 構 2. 後 測 式 重 複 結 構 for while do while 判 斷 false 敘 述 2 true 敘 述 1 敘 述 3 結 束 五 前 置 處 理 器 ( 一 )#define 前 置 處 理 器 1. 增 加 程 式 的 易 讀 性 2. 簡 化 修 改 常 數 或 字 串 內 容 時 的 複 雜 度 3. 增 加 程 式 執 行 效 率 4. 巨 集 (Macro) 的 使 用 可 取 代 簡 單 的 函 數 4

7 #define MAX #define WORD "This is a test!" #define AREA(w, h) ((w)*(h)) #define POWER(i) (i)*(i)*(i) int main() printf("%d \n", MAX); printf(word); printf("area = %d \n", AREA(5, 3)); printf("%d * %d * %d = %d \n", i+1, i+1, i+1, POWER(i+1)); ( 二 )#include 前 置 處 理 器 #include 前 置 處 理 器 是 將 標 頭 檔 (.h) 含 括 進 程 式 中, 相 關 使 用 方 法 如 下 表 使 用 說 明 用 法 < > 到 系 統 設 定 的 目 錄 尋 找 該 檔 案 #include <stdio.h> 如 :C:\Dev-C++\Include\ " " 依 指 定 的 目 錄 尋 找 該 標 頭 檔 #include "D:\myprog\area.h" 5

8 一 這 邊 使 用 Dev C 來 做 介 紹 單 元 2: 整 合 開 發 環 境 介 紹 為 提 高 程 式 可 攜 性, 大 部 分 廠 商 都 遵 循 ANSI C 的 標 準 程 式 開 發 環 境 由 早 期 各 自 獨 立 分 開 程 式 編 輯 器 編 譯 器 或 直 譯 器 執 行 或 除 錯, 隨 著 作 業 系 統 的 發 展 而 演 變 成 將 程 式 編 輯 器 編 譯 器 或 直 譯 器 執 行 或 除 錯 整 合 在 同 一 環 境 下 操 作, 不 但 提 高 親 和 力 而 且 提 高 了 程 式 開 發 的 效 率 本 章 介 紹 市 面 流 行 的 Dev C++ 5.0(beta 9) Visaul C 開 發 環 境, 讓 您 以 自 己 熟 悉 的 環 境 配 合 合 法 的 C 語 言 軟 體 來 學 習 C 語 言 的 程 式 設 計 Dev C++ 5.0(beta 9) 是 一 套 免 費 軟 體 能 在 整 合 環 境 下 開 發 C 語 言 的 程 式, 可 直 接 連 上 : or=jaist Step1 以 Windows XP 作 業 系 統 的 環 境 為 主, 執 行 [ 開 始 / 所 有 程 式 (P)/ Bloodshed Dev-C++/Dev-C++], 此 時 即 進 入 Dev-C++ 整 合 開 發 環 境 內 接 著 請 按 鈕, 將 每 日 提 示 視 窗 關 閉 Step2 1. 依 下 圖 步 驟 指 示, 新 增 Console Application 類 型 專 案, 並 設 定 該 專 案 使 用 C 語 言 來 開 發 執 行 功 能 表 [ 檔 案 (F)/ 開 新 檔 案 (N)/ 專 案 (P) ] 指 令, 開 啟 建 立 新 專 案 的 對 話 方 塊 6

9 2. 在 建 立 新 專 案 對 話 方 塊 中 切 換 到 Basic 標 籤 頁, 然 後 選 擇 要 新 增 專 案 的 類 型 為 Console Application, 再 選 取 C 專 案, 專 案 名 稱 設 為 first, 再 按 確 定 鈕 3. Create new project 對 話 方 塊, 指 定 專 案 欲 存 檔 的 路 徑, C:\devC\ ch02\first 資 料 夾 下, 必 頇 在 檔 案 視 窗 先 建 立 C:\devC\ch02\first, 切 換 視 窗 到 first 視 窗, 最 後 再 按 儲 存 鈕 將 此 專 案 置 於 first 資 料 夾 內 由 於 Dev C++ 在 編 譯 時 會 產 生 多 個 相 關 檔 案, 因 此 建 議 一 個 程 式 建 立 一 個 專 屬 的 資 料 夾 以 方 便 日 後 拷 貝 和 維 護 4. 新 增 專 案 後, 預 設 會 有 一 個 尚 未 存 檔 的 main.c 程 式 7

10 ( 二 ) 程 式 的 撰 寫 儲 存 執 行 與 關 閉 Step1 延 續 上 面 步 驟 在 下 圖 虛 框 處 撰 寫 下 面 指 定 的 兩 行 程 式 碼 : Step2 執 行 功 能 表 [ 檔 案 (F)/ 儲 存 (S)] 指 令 或 工 具 列 的 儲 存 所 有 專 案 鈕, 開 啟 儲 存 檔 案 對 話 方 塊, 將 檔 案 命 名 為 first.c, 並 將 該 檔 儲 存 在 C:\devC\ch02\first 資 料 夾 下 將 檔 名 (N) 預 設 值 main 改 成 first, 最 後 按 鈕, 此 時 整 合 開 發 編 輯 畫 面 會 如 下 圖 由 main.c 標 籤 頁 變 成 first.c 標 籤 頁 : 8

11 Step3 如 下 圖 執 行 功 能 表 的 [ 執 行 (Z)/ 編 譯 並 執 行 (O)] 指 令 或 按 F9 快 速 鍵, 編 譯 並 執 行 程 式, 觀 看 程 式 執 行 結 果 9

12 ( 三 ) 開 啟 與 關 閉 專 案 檔 一 開 啟 專 案 開 啟 C 語 言 程 式 檔 若 想 繼 續 編 輯 程 式, 首 先 必 頇 先 開 啟 專 案 檔, 接 著 再 開 啟 欲 編 輯 的 原 始 程 式 檔 接 著 以 開 啟 first.dev 專 案 和 first.c 檔 為 例 其 操 作 步 驟 如 下 : Step1 執 行 功 能 表 的 [ 檔 案 (F)/ 開 啟 專 案 一 般 檔 案 (O) ] 開 啟 開 啟 檔 案 對 話 方 塊 : 10

13 使 用 Visual C Visual C 是 開 發 C++ 程 式 的 利 器, 這 一 節 所 撰 寫 程 式 的 附 檔 名 為 *.cpp 檔 若 你 安 裝 書 附 的 Visual Studio 2008 Express 後, 可 依 下 面 步 驟 練 習 開 發 C++ 專 案 新 增 專 案 檔 Step1 以 Windows XP 作 業 系 統 的 環 境 為 主, 執 行 [ 開 始 / 所 有 程 式 (P)/ Microsoft Visual Studio 2008/Microsoft Visual Studio 2008], 此 時 如 下 圖 進 入 Visual Studio 2008 的 整 合 開 發 環 境 內 Step2 新 增 Win32 主 控 台 應 用 程 式 類 型 的 專 案, 其 專 案 名 稱 為 first, 並 將 此 專 案 資 料 夾 建 置 在 C:\vc2008\ch02\ first 執 行 功 能 表 [ 檔 案 (F)/ 新 增 專 案 (P)] 指 令 11

14 2. 接 著 出 現 下 圖 新 增 專 案 視 窗, 依 下 圖 步 驟, 選 擇 Visaul C++ 的 Win32 主 控 台 應 用 程 式 專 案 12

15 3. 接 著 出 現 first.cpp 程 式 檔 程 式 的 撰 寫 儲 存 與 執 行 延 續 前 一 節, 我 們 介 紹 如 何 在 Visual C 專 案 撰 寫 程 式 Step1 接 著 繼 續 在 first 專 案 的 first.cpp 檔 撰 寫 如 下 程 式 碼 13

16 Step2 撰 寫 程 式 完 成, 先 執 行 功 能 表 [ 檔 案 (F)/ 全 部 儲 存 (L)] 或 按 下 工 具 列 的 存 檔 案 動 作 圖 示 鈕 進 行 儲 Step3 接 著 您 可 以 執 行 功 能 表 的 [ 偵 錯 (D)/ 開 始 偵 錯 (S)] 執 行 程 式 並 觀 看 結 果 如 下 圖, 以 本 範 例 first 專 案 為 例, 執 行 功 能 表 的 [ 偵 錯 (D) / 開 始 偵 錯 (S)] 會 出 現 程 式 的 執 行 結 果 如 下 圖 : 開 啟 與 關 閉 專 案 檔 一. 關 閉 專 案 若 不 想 繼 續 編 輯 程 式 了, 可 以 執 行 功 能 表 的 [ 檔 案 (F)/ 結 束 (X)] 關 閉 目 前 正 在 編 輯 的 專 案 檔, 接 著 再 按 下 Visual C 整 合 開 發 環 境 的 鈕 即 可 以 離 開 Visual C 的 整 合 開 發 環 境 14

17 二. 開 啟 專 案 開 啟 C++ 程 式 檔 若 想 繼 續 編 輯 程 式, 首 先 必 頇 先 開 啟 專 案 檔, 接 著 再 開 啟 欲 編 輯 的 程 式 檔 接 著 就 以 開 啟 first.sln 方 案 ( 方 案 檔 的 附 檔 名 為 *.sln) 和 first.cpp 檔 為 例 如 下 步 驟 操 作 : Step1 若 要 開 啟 first.sln 方 案 檔, 如 下 圖 請 執 行 功 能 表 [ 檔 案 (F)/ 開 啟 專 案 (P)], 接 著 會 出 現 開 啟 專 案 對 話 方 塊, 請 選 取 欲 開 啟 的 first.sln 方 案 檔, 最 後 再 按 下 開 啟 鈕 即 可 Step2 開 啟 專 案 之 後, 若 想 繼 續 編 輯 程 式, 可 點 選 方 案 總 管 視 窗 開 啟 指 定 的 原 始 程 式 檔 如 下 圖, 在 方 案 總 管 視 窗 點 選 first.cpp 即 可 開 啟 該 程 式 檔 繼 續 編 輯 15

18 單 元 3: 基 本 資 料 型 態 與 算 術 運 算 (Unit 3: Basic Data Types and Arithmetic Calculations) 一 變 數 與 資 料 型 態 ( 一 ) 變 數 與 常 數 1. 變 數 (variable): 變 數 (variable) 是 利 用 宣 告 的 方 式, 將 記 憶 體 中 的 某 個 區 塊 配 置 給 此 變 數, 不 管 變 數 的 值 如 何 改 變, 它 會 一 直 佔 用 相 同 的 記 憶 體 空 間 例 : int i=3; float f=15.7; char ch='y'; 2. 常 數 (constant): 常 數 (constant) 的 值 是 固 定 的, 如 整 數 常 數 字 元 常 數 等 例 :const int max=65536; ( 二 ) 基 本 資 料 型 態 資 料 型 態 位 元 組 範 圍 備 註 char ( 字 元 ) 1 0~255 用 來 儲 存 英 文 字 母 及 ASCII 碼 int ( 整 數 ) ~32767 可 在 int 之 前 加 上 修 飾 詞 (qualifier), unsigned short long float ( 浮 點 數 ) 4 1.2e-38~3.4e38 可 用 小 數 點 及 指 數 型 態 表 示 double ( 雙 精 度 浮 點 數 ) 8 2.2e-308~1.8e308 可 用 小 數 點 及 指 數 型 態 表 示 ( 三 ) 變 數 的 命 名 原 則 : 所 有 的 變 數 必 頇 在 使 用 前 宣 告 命 名 原 則 主 要 包 含 以 下 七 項 1. 不 能 使 用 關 鍵 字 2. 只 有 前 8 個 字 元 為 有 效 字 元 3. 可 使 用 英 文 字 母 數 字 或 底 線 4. 變 數 名 稱 中 間 不 可 以 有 空 白 5. 第 一 個 字 元 不 可 為 數 字 6. 變 數 名 稱 要 有 意 義, 且 長 短 適 中 7. 大 小 寫 有 別 ( 四 ) 資 料 型 態 轉 換 1. 指 派 轉 換 ( x = 100; ) 2. 算 術 轉 換 ( y = i * / 23; ) 3. 模 式 轉 換 ( i = (int) ( x ); ) 4. 函 數 轉 換 ( x = sum (a, b); ) 16

19 二 運 算 子 與 運 算 式 ( 一 ) 基 本 運 算 子 1. 算 術 運 算 子 運 算 子 意 義 int a=9,b=4 運 算 結 果 + 加 法 a+b 13 - 減 法 a-b 5 * 乘 法 a*b 36 / 除 法 a/b 2 % 取 餘 數 a%b 1 2. 關 係 運 算 子 運 算 子 意 義 例 子 運 算 結 果 > 大 於 2>3 false >= 大 於 等 於 2>=3 false < 小 於 2<3 True <= 小 於 等 於 2<=3 true == 等 於 2==3 false!= 不 等 於 2!=3 true 3. 邏 輯 運 算 子 運 算 子 意 義 && AND, 且 OR, 或! NOT, 否 運 算 子 原 式 簡 潔 運 算 式 += a=a+b a+=b -+ a=a-b a-=b *= a=a*b a*=b /= a=a/b a/=b %= a=a%b a%=b a b a&&b a b ( 二 ) 其 他 常 用 的 運 算 子 1. 遞 增 / 減 運 算 子 運 算 子 意 義 int i=3; int a; 運 算 結 果 ++ 變 數 值 加 1 i 變 數 值 減 1 i-- 2 a = i a = ++i 4 4 a = i a = --I 2 2 i++: 先 執 行 整 個 敘 述 後, 再 將 i 的 值 加 1 ++i: 先 將 i 的 值 加 1, 再 執 行 整 個 敘 述 i a 17

20 各 種 運 算 子 在 運 算 式 中 優 先 執 行 順 序 2. 條 件 運 算 子 運 算 子 (?:) 意 義 if( 判 斷 條 件 ) 運 算 式 1; 條 件 判 斷? 運 算 式 1 : 運 算 式 2 else 運 算 式 2; 實 例 if (x > 100) a = b; a = (x > 100)? b : c; else a = c; if (a > 0) abs = a; abs = (a > 0)? a : -a; else abs = -a; 三 保 留 字 (Reserve Word) 保 留 字 又 稱 關 鍵 字 (Keyword) 是 事 先 賦 予 某 個 識 別 字 特 別 的 用 途, 以 供 程 式 設 計 呼 叫 或 使 用, 不 允 許 重 複 使 用 18

21 四 逸 出 字 元 (Escape Sequence) - 有 些 字 元 像 是 單 引 號 ( ) 雙 引 號 ( ) 及 反 斜 線 (\) 均 已 事 先 定 義 其 功 能, 當 做 程 式 中 的 控 制 字 元, 將 這 些 字 元 稱 為 逸 出 字 元 - 這 些 字 元 在 程 式 中 使 用 時, 必 頇 在 該 字 元 的 前 面 加 上 一 個 倒 斜 線 ( \ ) 構 成 逸 出 序 列, 以 供 printf() 函 式 顯 示 訊 息 用 - 編 譯 器 掃 描 到 這 些 特 殊 逸 出 字 元 時, 會 將 接 在 倒 斜 線 後 面 的 字 元, 當 成 某 種 特 殊 意 義 來 處 理 逸 出 字 元 一 覽 表 19

22 單 元 4: 格 式 化 輸 入 與 輸 出 (Unit 4: Formatted input and output) 一 標 準 輸 出 指 令 printf(" 格 式 字 串 ", var1, var2, ); 二 跳 脫 字 元 (Escape Sequence) \n 換 行 \" 雙 引 號 \x ASCII 碼 (16 進 位 ) \f 換 頁 \' 單 引 號 \d ASCII 碼 (8 進 位 ) \t 跳 格 \/ 斜 線 \b 倒 退 \\ 反 斜 線 例 子 printf("\tthis line begins with tab.\n"); printf("it\'s a \"C Tutorial\".\n"); printf("this is backslash: \\.\n"); printf("\\101 is \d101.\n"); printf("\\x41 is \x41.\n"); 執 行 結 果 This line begins with tab. It's a "C Tutorial". This is backslash: \. \101 is A. \x41 is A. 三 修 飾 子 修 飾 子 意 義 %s 字 串 %u 無 號 十 進 位 整 數 - 向 左 靠 齊 %d 十 進 位 整 數 %e 浮 點 數 ( 指 數 e 型 式 ) + 印 出 正 負 號 %f 浮 點 數 ( 小 數 點 型 式 ) %c 字 元 修 飾 子 意 義 修 飾 子 意 義 %l 長 整 數, 加 在 d u 之 前 四 格 式 化 輸 出 : 使 用 修 飾 子 資 料 格 式 結 果 %10d %+d %-10d % d %010d %7.2f %010.3f %+10.4f 五 標 準 輸 入 指 令 scanf(" 格 式 化 字 串 ", &var1, &var2, ); 1. & 是 位 址 運 算 子 2. 字 元 陣 列 不 需 要 加 上 & 位 址 運 算 子 20

23 輸 入 格 式 意 義 %d 十 進 位 整 數 int %f 浮 點 數 float, double 例 子 int num1, num2; printf("enter 2 numbers: "); scanf("%d,%d",&num1,&num2); 輸 入 格 式 意 義 %c 字 元 char %s 字 串 字 元 陣 列 執 行 結 果 執 行 畫 面 : Enter 2 numbers: 輸 入 值 格 式 : 103,227 ANSI C 所 提 供 的 標 準 輸 出 入 函 式 如 下 表 所 示 本 單 元 題 庫 1. 輸 入 三 個 整 數 a b c, 印 出 此 三 數 的 最 大 值 最 小 值 總 和 及 帄 均 值 2. 輸 入 兩 整 數 的 四 則 運 算 式 (a+b, a-b, a*b, a/b, a%b), 印 出 其 計 算 結 果 21

24 單 元 5: 選 擇 敘 述 結 構 (Unit 5: Selections Structure) 一 if 敘 述 程 式 中 的 選 擇 結 構 有 如 口 語 中 的 如 果.. 就 否 則. 在 C 中 是 使 用 if-else 敘 述 來 達 成 if 敘 述 if else 巢 狀 if if else if else if ( 判 斷 條 件 ) 敘 述 1; else 敘 述 2; if ( 判 斷 條 件 ) 敘 述 ; if ( 判 斷 條 件 ) 敘 述 1; 敘 述 n; if ( 判 斷 條 件 ) 敘 述 主 體 1; else 敘 述 主 體 2; if ( 判 斷 條 件 1) 敘 述 主 體 1; if ( 判 斷 條 件 2) 敘 述 主 體 2; if ( 判 斷 條 件 ) 敘 述 主 體 1; else if ( 判 斷 條 件 ) 敘 述 主 體 2; else 敘 述 主 體 n; 22

25 二 switch 敘 述 如 有 一 個 資 料, 有 兩 個 以 上 不 同 條 件 需 做 判 斷, 依 不 同 條 件 給 予 不 同 執 行 結 果, 若 使 用 太 多 的 else if 可 讀 性 不 高, 這 時 使 用 switch 最 為 適 當 switch 敘 述 使 用 時 需 注 意 事 項 switch ( 運 算 式 ) 1. 選 擇 值 只 能 是 字 元 或 常 數 2.break 用 於 跳 離 switch 區 塊 case 選 擇 值 1: 3. 當 選 擇 值 皆 不 成 立 時 預 設 處 理 程 序 放 在 default 裡 頭 敘 述 主 體 1; break; case 選 擇 值 2: 敘 述 主 體 2; break; case 選 擇 值 n: 敘 述 主 體 n; break; default: 敘 述 主 體 ; 本 單 元 題 庫 1. 利 用 switch 敘 述, 將 輸 入 的 成 績 ( 分 數 ) 以 下 列 方 式 分 級 90~100: A 級 80~89: B 級 70~79: C 級 60~69: D 級 0~59: E 級 23

26 一 比 較 for / while / do while 單 元 6: 反 覆 敘 述 結 構 (Unit 6: Repetitions Structure) for 敘 述 while 敘 述 do while 敘 述 for ( 初 值 ; 判 斷 條 件 ; 增 減 量 ) 設 初 值 ; 設 初 值 while ( 判 斷 條 件 ) do 敘 述 1; 敘 述 2; 敘 述 n; 敘 述 1; 敘 述 2; 敘 述 1; 敘 述 2; 敘 述 n; 設 增 減 量 ; 敘 述 n; 設 增 減 量 ; while ( 判 斷 條 件 ); for (i=1,sum=0;i<=9;i+=2) sum += i; printf("i=%d\n", i); printf("sum=%d\n",sum); printf("\n"); 實 例 : 請 使 用 重 複 敘 述 結 構 撰 寫 一 程 式 計 算 的 結 果 i=1; sum=0; while(i<=9) sum += i; printf("i=%d\n", i); printf("sum=%d\n",sum); printf("\n"); i += 2; i=1; sum=0; do sum += i; printf("i=%d\n", i); printf("sum=%d\n",sum); printf("\n"); i += 2; while (i<=9); 24

27 二 無 窮 迴 圈 指 令 用 法 while (1) 敘 述 主 體 ; 三 空 迴 圈 指 令 用 法 for ( 設 初 值 ; 判 斷 條 件 ; 設 增 減 量 ) 或 for ( 設 初 值 ; 判 斷 條 件 ; 設 增 減 量 ) ; 25

28 四 巢 狀 迴 圈 for 之 巢 狀 迴 圈 for ( 初 值 1; 條 件 1; 增 減 量 1) for ( 初 值 2; 條 件 2; 增 減 量 2) while 之 巢 狀 迴 圈 初 值 1; while ( 條 件 1) 初 值 2; while ( 條 件 2) 增 減 量 2; 增 減 量 1; 26

29 五 迴 圈 的 跳 離 break( 跳 出 迴 圈 ) continue( 回 到 迴 圈 開 始 處 ) for ( 設 初 值 ; 判 斷 條 件 ; 設 增 減 量 ) for ( 設 初 值 ; 判 斷 條 件 ; 設 增 減 量 ) 敘 述 1; 敘 述 1; 敘 述 2; 敘 述 2; break; continue; 敘 述 n; 敘 述 n; 備 註 : 在 while / do while 迴 圈 中 的 用 法 相 同 本 單 元 題 庫 1. 輸 入 正 整 數 n (1) 求 n 的 值 (2) 求 1 * 2 * * n 的 值 (3) 求 1! + 2! + + n! 的 值 2. 輸 入 大 於 2 的 正 整 數 n (1) 求 小 於 等 於 n 的 所 有 質 數 (2) 求 小 於 n 的 所 有 質 因 數 27

30 單 元 7: 函 式 (Unit 7. Functions) 二 函 式 抽 象 化 (abstraction) 的 機 制 可 以 簡 化 複 雜 的 觀 念 或 事 物, 常 見 的 有 資 料 抽 象 化 (data abstraction) 與 控 制 抽 象 化 (control abstraction) 副 程 式 (subroutine) 是 達 成 控 制 抽 象 化 (control abstraction) 的 一 種 機 制, 呼 叫 的 敘 述 (caller) 利 用 副 程 式 的 名 稱 來 進 行 呼 叫, 然 後 等 待 副 程 式 完 成 執 行, 呼 叫 的 敘 述 提 供 的 參 數 稱 為 實 際 參 數 (actual parameters, 或 稱 arguments), 副 程 式 對 應 的 參 數 叫 做 正 式 參 數 (formal parameters) 會 傳 回 值 的 副 程 式 通 常 也 稱 為 函 式 (function), 沒 有 傳 回 值 的 副 程 式 則 稱 為 程 序 (procedure) 程 式 語 言 要 求 副 程 式 在 使 用 前 必 頇 先 宣 告, 目 的 是 檢 查 副 程 式 的 呼 叫 與 副 程 式 的 宣 告 是 否 一 致 當 副 程 式 被 呼 叫 時, 系 統 會 分 配 一 個 堆 疊 框 (stack frame), 也 稱 為 啟 動 紀 錄 (activation record) 物 件 的 存 取 只 要 透 過 一 個 相 對 於 堆 疊 框 指 標 (frame pointer) 的 位 址, 系 統 就 可 以 找 到 該 物 件 使 用 函 式 的 主 要 原 因 可 歸 納 為 以 下 三 種 : ( 一 ) 使 程 式 發 展 容 易 管 理 ( 二 ) 軟 體 再 使 用 ( 抽 象 化 的 技 術, abstraction) ( 三 ) 避 免 重 複 撰 寫 相 同 的 程 式 碼 三 函 式 (Function) 定 義 的 格 式 四 函 數 格 式 回 傳 值 型 態 函 式 名 稱 ( 參 數 列 ) 變 數 宣 告 ; 陳 述 句 ; return 回 傳 值 ; 範 例 int sum(int a, int b) int num; num = a + b; return num; 三 函 式 原 形 (Prototype) 編 譯 器 利 用 函 式 原 形 來 驗 證 函 式 的 呼 叫, 函 式 原 形 通 常 置 於 main() 函 式 外, 或 是 標 頭 檔 內 函 式 原 形 的 另 一 個 功 能 是 引 數 型 態 的 強 制 轉 換 函 數 原 形 格 式 傳 回 值 型 態 函 式 名 稱 ( 引 數 型 態 ); 範 例 int sum(int, int); 或 int sum(int a, int b); 標 頭 檔 (Header File,.h) 含 有 函 式 原 形, 以 及 這 些 函 式 所 需 的 各 種 資 料 型 態 和 常 數 的 定 義 我 們 可 以 撰 寫 自 己 的 標 頭 檔, 以.h 為 附 檔 名 在 原 始 程 式 檔 中, 以 #include 將 標 頭 檔 含 括 進 來 28

31 四 函 式 的 呼 叫 一 個 名 稱 的 有 效 範 圍 應 該 是 在 它 被 宣 告 時 所 在 的 範 圍 (scope), 所 以 一 個 副 程 式 裡 頭 所 宣 告 的 區 域 變 數 應 該 只 在 該 副 程 式 中 有 效 副 程 式 透 過 參 數 (parameter) 來 讓 外 界 改 變 它 們 的 行 為, 或 是 因 此 而 取 得 處 理 或 運 算 時 所 需 要 的 資 料, 副 程 式 也 可 以 透 過 全 域 變 數 (global variable) 取 得 資 料 而 參 數 傳 遞 通 常 可 使 用 以 下 二 種 方 式 達 成 : 1. 傳 值 呼 叫 (call by value): 將 引 數 值 拷 貝 一 份 傳 給 函 式, 不 會 影 響 原 來 的 變 數 值 而 在 傳 值 呼 叫 中, 傳 遞 的 參 數 a 的 值 會 指 定 給 對 應 的 正 式 參 數, 兩 者 之 間 沒 有 其 他 的 關 係, 假 如 這 個 值 在 f 中 被 改 變 也 不 影 響 a 的 值 2. 傳 參 考 呼 叫 (call by reference): 將 引 數 的 位 址 傳 給 函 式, 會 影 響 原 來 的 變 數 值 在 傳 址 呼 叫 中, 傳 遞 的 參 數 a 所 指 向 的 地 址 會 傳 給 對 應 的 正 式 參 數, 兩 者 指 向 相 同 的 位 址, 假 如 這 個 位 址 值 在 f 中 被 改 變 了 則 a 所 代 表 的 值 也 跟 著 改 變 了 29

32 五 遞 迴 函 式 (Recursive Function) 1. 自 己 呼 叫 自 己, 注 意 終 止 條 件 的 設 定 2. 用 到 大 量 的 堆 疊 (stack) 空 間, 容 易 造 成 記 憶 體 不 足 3. 可 以 改 寫 成 迴 圈 形 式 六 儲 存 體 類 別 (Storage Classes) 佔 用 期 間 類 別 說 明 動 態 靜 態 自 動 變 數 auto 暫 存 器 變 數 register 靜 態 變 數 static 外 部 變 數 extern 1. auto 變 數 是 在 程 式 控 制 進 入 所 宣 告 的 區 塊 時 才 被 產 生 出 來, 一 離 開 此 區 塊, 就 會 從 記 憶 體 中 消 失 了 2. 區 域 變 數 內 定 為 自 動 變 數 例 :auto float x,y; 1. 宣 告 成 register 的 變 數 會 放 到 硬 體 暫 存 器 中, 減 少 運 算 時 從 記 憶 體 載 入 的 負 擔 2. register 變 數 只 能 用 在 自 動 變 數 上 例 :register int counter = 1; 1. static 變 數 從 程 式 開 始 執 行 時 便 配 置 好 儲 存 體, 並 設 定 初 值 ( 數 值 預 設 為 0, 指 標 預 設 為 NULL) 2. static 變 數 包 含 內 部 靜 態 變 數 與 外 部 靜 態 變 數 例 :static int count = 1; 靜 態 1. 外 部 變 數 包 含 全 域 變 數 和 函 式 名 稱 2. 外 部 變 數 也 屬 於 靜 態 變 數, 在 程 式 開 始 執 行 時 便 佔 有 記 憶 體 空 間 七 範 圍 規 則 (Scope) 分 類 說 明 包 含 內 容 檔 案 範 圍 可 在 整 個 檔 案 中 使 用 1. 全 域 變 數 (Global Variable) 2. 函 式 定 義 3. 函 式 原 形 區 塊 範 圍 可 在 區 塊 內 使 用, 也 就 是 包 起 來 的 範 圍 1. 區 域 變 數 (Local Variable) 2. 巢 狀 區 塊 中 的 變 數 3. 函 式 的 參 數 函 式 範 圍 只 能 在 函 式 範 圍 內 使 用 標 名 : 1. goto 陳 述 句 的 標 名 2. switch 結 構 的 case 函 式 原 形 函 式 原 形 參 數 列 中 的 識 別 字 範 圍 30

33 單 元 8: 陣 列 (Unit 8: Arrays) 一 一 維 陣 列 ( 一 ) 宣 告 格 式 型 態 陣 列 名 稱 [ 個 數 ]; 範 例 : int score[10] = 80,90,95,75,100,80,85,95,90,60; 陣 列 裡 的 10 個 元 素 score score[0] score[9] 陣 列 名 稱 每 個 元 素 佔 一 個 int 型 態 大 小 (4 bytes) sizeof(score) 4 * 10 = 40 bytes ( 二 ) 初 值 設 定 方 式 int data[5] = 1; /* 將 所 有 元 素 值 都 設 為 1 */ int num[] = 60,75,48,92; /* 依 照 初 值 設 定 的 個 數 決 定 陣 列 的 大 小 */ int student[10] = 1,2,3,4,5; /* 初 值 個 數 少 於 宣 告 元 素 個 數 時, 剩 餘 空 間 填 0 */ 二 二 維 陣 列 ( 一 ) 宣 告 格 式 型 態 陣 列 名 稱 [ 列 數 ][ 行 數 ]; 範 例 : int sale[2][4] = 10,20,30,40, 50,60,70,80; 2 列 4 行 sale[0][0] 10 sale[0][1] 20 sale[1][0] 50 sale[1][1] 60 陣 列 中 的 元 素 個 數 2*4=8 sizeof(sale) 4*(2*4)=32bytes ( 二 ) 初 值 設 定 方 式 : int temp[][4] = 1,2,3,4, /* 未 定 長 度 之 二 維 陣 列 的 初 值 設 定 */ 5,6,7,8, 9,10,11,12 ; 多 維 陣 列 的 宣 告 和 初 值 設 定 方 式 依 此 類 推 31

34 三 多 維 陣 列 陣 列 註 標 ( 索 引 ) 只 有 一 個, 稱 為 一 維 陣 列 維 度 為 1 一 個 資 料 需 要 使 用 兩 個 索 引 來 表 示 時, 此 種 陣 列 稱 為 二 維 陣 列 維 度 為 2 此 類 陣 列 有 如 Office 的 Excel, 工 作 表 中 的 某 個 儲 存 格 (Cell) 是 以 第 幾 列 第 幾 行 ( 欄 ) 來 表 示 其 位 置 二 維 陣 列 可 想 像 成 一 個 帄 面, 表 示 位 置 時 是 使 用 第 幾 列 第 幾 行 來 描 述 如 : 一 般 表 格 電 影 院 座 位 表 教 室 座 位 表 多 個 同 年 級 的 計 概 成 績 等 都 必 頇 使 用 二 維 陣 列 來 表 示 陣 列 含 有 三 個 索 引 時, 就 成 為 三 維 陣 列, 維 度 為 3, 此 類 陣 列 可 以 想 像 成 由 好 幾 個 教 室 疊 起 來 的 立 體 大 樓, 描 述 位 置 時 必 頇 指 定 第 幾 層 樓 的 第 幾 列 的 第 幾 行 將 陣 列 的 維 度 是 二 維 ( 含 ) 以 上 稱 為 多 維 陣 列 欲 建 立 一 個 3x4 的 整 數 陣 列 a ( 即 3 個 水 帄 列 和 4 個 垂 直 行 ) 的 陣 列, 其 宣 告 方 式 如 下 : int a[3][4]; 四 陣 列 與 函 數 陣 列 可 以 當 作 引 數 傳 遞 到 函 數 中, 此 時 函 數 接 收 到 的 是 陣 列 的 位 址, 而 非 陣 列 的 值 事 實 上, 傳 遞 至 函 數 中 的 也 就 是 指 向 陣 列 位 址 的 指 標 (pointer) 範 例 #include <stdio.h> #define SIZE 5 void print_matrix(int A[]); /* 函 式 原 型 */ In main() Memory int main(void) int data[size] = 23,25,28,29,27; printf_matrix(data); return 0; void print_matrix(int A[]) int i; for (i=0; i<size; i++) printf("%d ", A[i]); printf("\n"); return; data FDB In print_matrix() A 為 指 標 常 數 0253FDB8 32

35 單 元 9: 指 標 (Unit 9: Pointer) 一 指 標 變 數 指 標 (Pointer) 是 一 種 特 殊 的 變 數, 用 來 存 放 變 數 在 記 憶 體 中 的 位 址 在 Dev C++ 中, 無 論 指 標 指 向 何 種 資 料 型 態, 指 標 變 數 本 身 均 佔 有 4 個 位 元 組 (bytes) 指 標 變 數 變 數 存 放 變 數 位 址 0253F3C4 ( 一 ) 宣 告 格 式 型 態 * 指 標 變 數 ; 範 例 : int *ptri; /* 整 數 型 態 之 指 標 變 數 */ char *ptrch; /* 字 元 型 態 之 指 標 變 數 */ 存 放 變 數 ex: F3C4 sizeof(ptri) sizeof(ptrch) 4 bytes 4 bytes 二 指 標 運 算 子 以 下 針 對 位 址 運 算 子 及 依 址 取 值 運 算 子 加 以 說 明 : ( 一 ) 位 址 運 算 子 &: 用 來 取 得 變 數 或 陣 列 元 素 在 記 憶 體 中 的 位 址 ( 二 ) 依 址 取 值 運 算 子 *: 用 來 取 得 指 標 所 指 向 的 記 憶 體 位 址 的 內 容 範 例 : int a = 10, b; int *p; p = &a; b = *p; *p = 20; 結 果 :a = 20, b = 10 33

36 三 指 標 的 運 算 以 下 針 對 設 定 運 算 加 / 減 法 運 算 及 差 值 運 算 三 類 運 算 進 行 說 明 : ( 一 ) 設 定 運 算 : 將 等 號 右 邊 的 值 設 定 給 左 邊 的 指 標 變 數 ( 二 ) 加 / 減 法 運 算 : 針 對 各 個 資 料 型 態 的 長 度 來 處 理 位 址 的 加 減 法 運 算 ( 三 ) 差 值 運 算 : 計 算 兩 個 指 標 之 間 的 距 離, 其 單 位 為 資 料 型 態 的 長 度 範 例 : int a=10, b=20; int *p1, *p2; char ch='a', *pch; /* 設 定 運 算 */ p1 = &a; /* 將 a 的 位 址 存 放 於 p1 */ p2 = &b; /* 將 b 的 位 址 存 放 於 p2 */ pch = &ch; /* 將 ch 的 位 址 存 放 於 pch */ /* 加 減 法 運 算 */ p1++; /* 將 p1 中 的 位 址 值 加 上 4 bytes (int 型 態 的 大 小 ) */ pch--; /* 將 pch 中 的 位 址 值 減 去 1 byte (char 型 態 的 大 小 ) */ /* 差 值 運 算 */ sub = p1 p2; /* 計 算 p1 和 p2 相 差 的 距 離 ( 以 int 為 單 位 的 距 離 ) */ 以 下 針 對 指 標 的 簡 潔 運 算 式, 使 用 範 例 加 以 說 明 : int X; int A[5] = 10,20,30,40,50; int *p = A + 2; 運 算 式 同 義 所 執 行 的 敘 述 及 順 序 執 行 後 X = *(p++); X = *p++; X = *p; p = p + 1; X = *(++p); X = *++p; p = p + 1; X = *p; X = (*p)++; X = *p; *p = *p + 1; X = ++(*p); *p = *p + 1; X = *p; X = *(p--); X = *p--; X = *p; p = p - 1; X = *(--p); X = *--p; p = p - 1; X = *p; X = (*p)--; X = *p; *p = *p - 1; X = --(*p); *p = *p - 1; X = *p; 34 X *p 四 指 標 與 函 數 函 數 的 return 敘 述 只 能 有 一 個 回 傳 值, 當 程 式 需 要 傳 遞 兩 個 以 上 的 值 時, 可 以 利 用 指 標 解 決 在 函 數 間 傳 遞 多 個 回 傳 值 的 問 題 其 做 法 是 將 指 標 當 作 引 數 傳 入 函 數 中, 由 於 指 標 內 的

37 值 是 所 指 向 變 數 的 位 址, 因 此 不 頇 經 過 return 敘 述 即 可 更 改 變 數 的 值 範 例 : void swap(int *, int *); /* 函 數 原 型, 參 數 為 兩 個 整 數 型 態 的 指 標 變 數 */ int main(void) int a=3, b=5; swap(&a, &b); /* 傳 遞 a 和 b 的 位 址 */ return 0; void swap(int *x, int *y) /* 此 函 數 用 來 交 換 x y 所 指 向 的 變 數 之 值 */ int temp = *x; *x = *y; *y = temp; 五 指 標 與 陣 列 的 關 係 陣 列 可 看 成 是 指 標 的 分 身, 陣 列 元 素 的 排 列 可 利 用 指 標 運 算 來 存 取 int a[3] = 5,7,9; 指 標 的 指 向 陣 列 註 標 陣 列 內 容 記 憶 體 位 址 陣 列 元 素 位 址 指 標 的 移 位 *(a+0) a[0] FDC8 &a[0] a+0 *(a+1) a[1] FDCC &a[1] a+1 *(a+2) a[2] FDD0 &a[2] a+2 兩 種 表 示 法 同 義 兩 種 表 示 法 同 義 注 意 : 陣 列 a 以 指 標 的 方 式 表 示 時,a 會 被 視 為 指 標 常 數, 所 以 不 可 寫 成 a++ 六 指 標 陣 列 陣 列 中 存 放 的 變 數 為 指 標 變 數, 即 為 指 標 陣 列 ( 一 ) 宣 告 格 式 : 型 態 * 陣 列 名 稱 [ 個 數 ]; int i=10,j=28,k=34; int* a[3]; a[0] = &j; a[0] i 10 a[1] = &k; a[1] j 28 a[2] = &i; a[2] k 34 35

38 ( 二 ) 字 串 陣 列 與 指 標 陣 列 比 較 1. 字 串 陣 列 :char name[3][10] = "David", "Jane Wang", "Tom Lee"; name[0] D a v i d \0 name[1] J a n e W a n g \0 name[2] T o m L e e \0 David, Jane Wang, Tom Lee ; name[0] D a v i d \0 name[1] J a n e W a n g \0 name[2] T o m L e e \0 可 節 省 浪 費 的 記 憶 體 空 間 2. 指 標 陣 列 :char *name[3] = 經 由 比 較 可 知, 利 用 指 標 陣 列 七 雙 重 指 標 指 向 指 標 的 指 標 指 標 變 數 中 若 是 存 放 另 一 個 指 標 變 數 的 位 址, 這 種 指 向 指 標 的 指 標 稱 為 雙 重 指 標 ( 一 ) 宣 告 格 式 : 型 態 ** 指 標 變 數 ; 雙 重 指 標 變 數 指 標 變 數 變 數 存 放 指 標 位 址 存 放 變 數 位 址 存 放 變 數 0253FDA4 0253FDD0 ex: FDA4 0253FDD0 八 動 態 配 置 記 憶 體 一 維 配 置 int n=5; int* p; p = (int*) malloc( n * sizeof(int) ); 5 n 0x02E0 p 0x02E0 0x02E4 0x02E8 0x02EC 0x02F0 配 置 n 個 int 36

39 37

40 單 元 10: 字 元 與 字 串 (Unit 10: Character and String) 一 字 元 陣 列 在 C 語 言 中 並 沒 有 字 串 的 資 料 型 態, 要 使 用 字 串 變 數, 就 要 宣 告 字 元 陣 列 字 串 常 數 儲 存 在 記 憶 體 時, 在 最 後 面 會 加 上 字 串 結 束 字 元 \0 做 結 尾 ( 一 ) 宣 告 格 式 : char 字 元 陣 列 名 稱 [ 字 串 長 度 ]; 範 例 : char name[15] = "Koala Ying"; name K o a l a Y i n g \0 比 較 下 列 三 種 宣 告 : 宣 告 說 明 char a[] = "My friend"; sizeof(a) 9 個 字 元 + 字 串 結 束 字 元 \0 = 10 bytes char b = c ; sizeof(b) 1 個 字 元 = 1 byte char str[] = "c"; sizeof(str) 1 個 字 元 + 加 上 字 串 結 束 字 元 \0 = 2 bytes 下 列 四 種 都 是 合 法 的 寫 法 1. char str1[6] = smart ; 2. char str1[] = smart ; 3. char str1[6]= s,'m, a, r, t, \0 ; 4. char str1[]= s, m, a, r, t, \0 ; ( 二 ) 字 串 的 輸 入 / 輸 出 函 數 方 法 1 方 法 2 語 法 scanf("%s", 字 元 陣 列 名 稱 ); gets( 字 元 陣 列 名 稱 ); printf("%s", 字 元 陣 列 名 稱 ); puts( 字 元 陣 列 名 稱 ); 說 明 scanf() 讀 到 Enter 或 空 白 時 就 結 束 讀 取 動 作, 同 時 在 字 串 結 尾 處 加 上 \0 1. gets() 在 讀 到 Enter 時 才 結 束 讀 取 動 作, 並 在 字 串 結 尾 處 加 上 \0 2. puts() 會 將 \0 轉 換 成 換 行 字 元, 在 輸 出 字 串 時 會 自 動 換 行 38

41 範 例 #include <stdio.h> int main(void) char name[15]; printf("what s your name?\n"); scanf("%s", name); printf("hi! %s How are you?\n", name); return 0; #include <stdio.h> int main(void) char name[15]; puts("what s your name?"); gets(name); puts("hi! "); puts(name); puts(" How are you?"); return 0; [ 範 例 ] 使 用 字 串 陣 列 name 來 存 放 十 位 同 學 的 英 文 名 字, 每 個 英 文 名 字 最 長 限 制 為 15 個 字 元 ( 含 結 束 字 元 ) 執 行 時, 連 續 輸 入 每 位 同 學 英 文 名 字, 當 輸 入 小 寫 的 stop 字 串, 便 結 束 輸 入 會 將 每 位 同 學 的 英 文 名 字 依 序 逐 行 顯 示 出 來 39

42 程 式 碼 FileName:string3.c 01 #include <stdio.h> 02 #include <stdlib.h> 03 #include <string.h> int main(int argc, char *argv[]) int i,count; 08 char name[10][15]; 09 for(i=0; i<10; i++) printf(" 請 輸 入 %d 號 同 學 的 英 文 名 字 :", i+1); 12 gets(name[i]); 13 if (strcmp(name[i],"stop")==0)/* 判 斷 是 否 輸 入 "stop" 字 串 */ count=--i; 16 break; printf("\n 共 輸 入 %d 位 同 學 的 英 文 名 字 ",count+1); 20 printf("\n=============================="); 21 for (i=0;i<=count;i++) printf("\n ==> 座 號 %d 號 同 學 的 英 文 名 字 : %s\n\n",i+1,name[i]); system("pause"); 26 return 0; 27 二 字 串 陣 列 ( 一 ) 宣 告 格 式 : char 字 元 陣 列 名 稱 [ 陣 列 大 小 ][ 字 串 長 度 ]; 範 例 : char name[3][10] = "David", "Jane Wang", "Tom Lee"; name[0] 0253FDB8 D a v i d \0 name[1] 0253FDC2 J a n e W a n g \0 name[2] 0253FDCC T o m L e e \0 name[0] 與 name[1] 相 差 10 bytes name[1] 與 name[2] 相 差 10 bytes 40

43 單 元 11: 檔 案 導 向 輸 入 與 輸 出 (Unit 11: File-Oriented Input and Output) 一 般 都 透 過 鍵 盤 輸 入 資 料, 將 輸 入 資 料 放 入 指 定 變 數 或 陣 列 再 進 行 處 理 缺 點 當 電 腦 闗 機 或 重 新 執 行, 輸 入 資 料 都 必 頇 重 新 輸 入 解 決 透 過 C 的 檔 案 處 理 函 式, 將 輸 入 資 料 存 在 指 定 資 料 檔 資 料 檔 附 檔 名 通 常 設 為 *.txt 或 *.dat 處 理 資 料 檔 中 的 資 料 透 過 檔 案 處 理 函 式, 取 得 資 料 檔 資 料 存 放 到 變 數 或 陣 列 進 行 處 理 資 料 處 理 完 畢 將 資 料 寫 回 指 定 的 資 料 檔 好 處 資 料 易 維 護 且 同 份 程 式 可 處 理 相 同 資 料 格 式 檔 名 不 同 的 資 料 檔, 增 加 程 式 彈 性 一 檔 案 I/O 與 作 業 系 統 檔 案 I/O 與 字 元 I/O 都 屬 C 的 標 準 函 式 庫 OS 均 有 提 供 但 使 用 不 易 (DOS-ASM) 檔 案 I/O 各 自 不 同 ANSI 提 供 標 準 函 式 庫 I/O 與 OS 由 編 譯 器 提 供 介 面 二 檔 案 儲 存 在 記 憶 體 的 形 式 類 型 儲 存 方 式 儲 存 單 位 檔 案 大 小 檔 案 類 型 文 字 檔 text file 以 ASCII 碼 儲 存 每 個 字 元 皆 佔 有 1 個 位 元 組, 如 數 值 為 6 個 字 元 較 大 ( 資 料 相 同 時 ) 文 字 資 料 二 進 位 檔 binary file 以 二 進 位 的 格 式 儲 存 三 檔 案 存 取 模 式 代 碼 存 取 模 式 R 讀 取 舊 檔 W 覆 寫 新 舊 檔 A 附 加 新 舊 檔 代 碼 存 取 模 式 r+ 讀 取 覆 寫 舊 檔 w+ 讀 取 覆 寫 新 舊 檔 a+ 讀 取 附 加 新 舊 檔 以 資 料 型 態 的 長 度 為 儲 存 單 位, 如 整 數 在 Dev C++ 中 佔 有 4 個 位 元 組 較 小 ( 資 料 相 同 時 ) 圖 形 檔 聲 音 檔 影 像 檔 代 碼 rb wb ab 存 取 模 式 讀 取 二 進 位 檔 覆 寫 二 進 位 檔 附 加 二 進 位 檔 41

44 三 檔 案 處 理 函 數 (Standard I/O) 函 式 ( 有 緩 衝 區 ) 緩 衝 區 (Buffer) 即 是 指 資 料 在 存 取 時, 為 加 快 程 式 執 行 速 度, 在 主 記 憶 體 中 先 建 立 一 塊 緩 衝 區 來 存 放 部 分 資 料, 再 透 過 緩 衝 區 來 存 取 整 塊 資 料, 不 直 接 和 磁 碟 進 行 存 取 動 作 ( 一 ) 變 數 宣 告 : FILE *file; char ch; char buffer[128]; 名 稱 功 能 使 用 範 例 fopen 開 檔 file = fopen( C:\abc.txt, r ); fclose 關 檔 fclose(file); getc 讀 取 字 元 ch = getc(file); putc 寫 入 字 元 putc(ch, file); fgets 讀 取 字 串 fget(buffer, 128, file); fputs 寫 入 字 串 fputs(buffer, file); fprintf 格 式 化 輸 出 fprintf(file, %c \n, ch); fscanf 格 式 化 輸 入 fscanf(file, %c, &ch); fread 區 塊 輸 入 fread(buffer, sizeof(char), 128, file); fwrite 區 塊 輸 出 fwrite(buffer, sizeof(char), 128, file); feof 檢 查 是 否 結 束 while(!feof(file) ) ch = getc(file); ferror 檢 查 錯 誤 if ( ferror(file) ) printf( error ); fseek 移 動 檔 案 指 標 位 置 fseek(file, 128, SEEK_SET); 42

45 四 命 令 列 參 數 的 使 用 ( 一 ) 語 法 main(argc, argv) int argc; char *argv[];... main(int argc, char* argv[])... ( 二 ) 參 數 說 明 1.argc (argument count): 記 錄 參 數 個 數 2.argv (argument value): 記 錄 參 數 值 argv[0] 記 錄 程 式 名 稱, 後 面 接 續 的 參 數 依 序 指 定 給 argv[1] argv[2]... 命 令 範 例 type 123 abc.txt argc = 3; argv[0] = type ( 程 式 名 稱 ) argv[1] = 123 argv[2] = abc.txt 命 令 範 例 #include <stdio.h> int main (int argc, char* argv[]) int i; printf( The value of argc is %d \n, argc); for(i=0; i<argc; i++) printf( argv[%d]=%s \n, i, argv[i]); return 0; 43

46 程 式 碼 FileName:fputc_p.c 01 #include <stdio.h> 02 #include <stdlib.h> 03 #include <string.h> 04 #include <ctype.h> 05 #include <conio.h> 06 #include <io.h> 07 #define LEN int main(int argc, char *argv[]) FILE *fptr; 12 char fpath[len], keyin[len]; 13 int fno, fsize, i; 14 char ch; 15 printf(" 寫 檔 作 業...\n"); 16 printf(" 請 輸 入 要 開 啟 檔 案 的 完 整 路 徑 及 檔 名 :"); 17 gets(fpath); 18 fptr=fopen(fpath, "a+"); 19 if(fptr==null) printf("\n 開 檔 失 敗, %s 可 能 不 存 在 \n", fpath); 22 exit(0); while(1) printf("\n 請 問 是 否 要 繼 續 新 增 資 料 (Y/N):"); 27 if(toupper(getche())=='y') printf("\n 請 輸 入 要 新 增 的 資 料 :"); 30 gets(keyin); 31 for(i=0; i<strlen(keyin) ; i++) fputc(keyin[i], fptr); fputc('\n', fptr); else fclose(fptr); 40 break; printf("\n\n"); 44 system("pause"); 45 return 0; 46 44

47 單 元 12: 結 構 與 其 他 資 料 型 態 (Unit 12: Structures) C 提 供 整 數 浮 點 數 字 元 陣 列 等 基 本 資 料 型 別 這 些 資 料 型 別 不 敷 使 用 C 另 提 供 下 列 保 留 字 讓 使 用 者 可 在 程 式 中 依 自 己 需 求 定 義 新 的 資 料 型 別 一 結 構 (Structure) ( 一 ) 格 式 : struct 結 構 名 稱 資 料 型 態 欄 位 名 稱 1; 資 料 型 態 欄 位 名 稱 2; ; ( 二 ) 結 構 的 宣 告 及 使 用 範 例 struct mydata /* 結 構 名 稱 */ char name[15]; /* 欄 位 */ int score; /* 欄 位 */ ; /* 宣 告 結 構 變 數 並 設 定 初 值 */ struct mydata teacher = "Apric",90; #include <stdio.h> /* 公 用 的 結 構 通 常 定 義 為 外 部 變 數 的 型 式 */ struct mydata /* 結 構 名 稱 */ char name[15]; /* 欄 位 */ int score; /* 欄 位 */ teacher = "Apric",90; /* 宣 告 結 構 變 數 並 設 定 初 值 */ int main(void) sturct mydata student; /* 宣 告 結 構 變 數 */ printf("name: "); scanf("%s", student.name); printf("score: "); scanf("%d", &student.score); printf("%s got %d points! \n", student.name, student.score); return 0; 45

48 二 巢 狀 結 構 範 例 struct date /* 結 構 名 稱 */ int month; int day; ; struct newdata /* 結 構 名 稱 */ char name[15]; struct date birthday; /* 結 構 變 數 */ int score; ; int main(void) struct newdata student = "Apric", 7, 10, 90; printf("%s's birthday is %d/%d \n", student.name, student.birthday.month, student.birthday.day); printf("he/she got %d points! \n", student.score); return 0; 三 結 構 陣 列 範 例 struct mydata student[10]; for(i=0; i<10; i++) printf("%s got %d points! \n", student[i].name, student[i].score); 定 義 一 個 產 品 結 構 名 稱 為 product 用 來 表 示 CD 唱 片, 擁 有 no 欄 位 代 表 CD 的 書 號 編 號, title 欄 位 代 表 CD 的 抬 頭 名 稱, price 欄 位 代 表 CD 的 售 價 三 個 欄 位 成 員, 其 寫 法 如 下 : 四 結 構 指 標 範 例 struct mydata student[10]; /* 結 構 陣 列 */ struct mydata *ptr = student; /* 結 構 指 標, 初 值 為 student 陣 列 的 起 始 位 址 */ for (i=0;i<10;i++) printf("name, Score:"); scanf("%s, %d", (student+i) name, &(student+i) score); printf("%s got %d points!\n", ptr name, ptr score); ptr++; 46

49 五 結 構 與 函 數 範 例 void get_data(struct mydata *p); /* 函 式 原 型, 參 數 為 結 構 指 標 */ void print_data(struct mydata a); /* 函 式 原 型, 參 數 為 結 構 變 數 */ int main(void) struct mydata student; get_data(&student); print_data(student); return 0; void get_data(struct mydata *p) printf("name:"); scanf("%s", p name); printf("score:"); scanf("%d", &p score); void print_data(struct mydata a) printf("%s got %d!\n", a.name, a.score); return; 六 自 訂 型 態 (typedef) ( 一 ) 格 式 : typedef 資 料 型 態 識 別 字 ; typedef 由 編 譯 器 執 行 typedef int clock; clock hour, second; #define 由 前 置 處 理 器 主 導 #define CLOCK int CLOCK hour, second; ( 二 ) 利 用 typedef 自 訂 新 的 結 構 型 態 : typedef struct int minite; float second; time; time record = 3, 27.25; 47

50 單 元 13: 遞 迴 (U13:Recursion) 一 遞 迴 函 式 (Recursive Function) 遞 迴 函 式 是 指 利 用 直 接 或 者 是 間 接 的 方 式 ( 透 過 其 他 函 數 ) 呼 叫 自 己, 一 般 而 言 它 具 備 以 下 三 種 特 性 : ( 一 ) 自 己 呼 叫 自 己, 注 意 終 止 條 件 的 設 定 ( 二 ) 用 到 大 量 的 堆 疊 (stack) 空 間, 容 易 造 成 記 憶 體 不 足 ( 三 ) 可 以 改 寫 成 迴 圈 形 式 在 利 用 遞 迴 解 決 問 題 時, 通 常 利 用 去 解 決 問 題 中 的 最 基 本 狀 況 (base case), 如 果 我 們 在 基 本 狀 況 下 呼 叫 遞 迴 函 數, 該 函 數 會 直 接 傳 回 結 果 否 則 遞 迴 函 數 會 把 問 題 切 割 成 兩 個 部 分 : ( 一 ) 知 道 如 何 處 理 的 部 分 ( 二 ) 遞 迴 函 數 不 知 如 何 處 理 的 部 分 因 此 利 用 遞 迴 函 數 需 要 確 認 另 一 部 份 不 知 如 何 處 理 的 概 念 需 與 最 基 本 狀 況 的 原 問 題 很 相 似 範 例 : 5! 的 遞 迴 運 算 概 念 48

51 1 // Fig. 6.29: fig06_29.cpp 2 // Testing the recursive factorial function. 3 #include <iostream> 4 using std::cout; 5 using std::endl; 6 7 #include <iomanip> 8 using std::setw; 9 10 unsigned long factorial( unsigned long ); // function prototype int main() // calculate the factorials of 0 through for ( int counter = 0; counter <= 10; counter++ ) 16 cout << setw( 2 ) << counter << "! = " << factorial( counter ) 17 << endl; return 0; // indicates successful termination 20 // end main First call to factorial function 二 使 用 遞 迴 處 理 費 氏 數 列 (Fibonacci) ( 一 ) 費 氏 數 列 1. 其 數 列 順 序 為 :0, 1, 1, 2, 3, 5, 8, 13, 21, 2. 是 由 0 與 1 開 始 3. 每 個 後 續 的 費 氏 數 值 是 它 的 前 兩 個 數 值 之 和 ( 二 ) 費 氏 數 列 能 藉 由 遞 迴 函 數 定 義 如 下 : 1.fibonacci(0) = 0 2.fibonacci(1) = 1 3.fibonacci(n) = fibonacci(n 1) + fibonacci(n 2) ( 三 ) 費 氏 數 列 階 層 概 念 圖 ( 四 ) 範 例 問 題 : 費 氏 數 列 中 第 n 項 的 值 等 於 前 兩 項 的 合, 如 設 f(n) 表 示 第 n 項, 根 據 定 義 :f(n) = f(n-1) + f(n-2) 請 利 用 遞 迴 函 數, 求 出 f(n) int f(int n) if (n==1 n==2) return 1; else return f(n-1)+f(n-2); 49

52 三 使 用 遞 迴 解 決 河 內 塔 問 題 河 內 塔 (Tower of Hanoi) 問 題 是 說 明 遞 迴 觀 念 時, 不 可 錯 過 的 一 個 重 要 範 例, 這 是 流 傳 在 Brahma 廟 內 的 遊 戲, 廟 內 的 僧 侶 相 信 完 成 這 個 遊 戲 是 一 件 不 可 能 的 任 務 河 內 塔 問 題 共 有 3 根 木 樁, 如 下 圖 所 示 : 上 述 圖 例 一 共 有 n 個 盤 子 放 置 在 第 1 根 木 樁, 盤 子 的 尺 寸 由 上 而 下 依 序 遞 增 河 內 塔 問 題 是 將 所 有 的 盤 子 從 木 樁 1 搬 移 到 木 樁 3, 其 搬 動 規 則, 如 下 所 示 : ( 一 ) 每 次 只 能 移 動 一 個 盤 子, 而 且 只 能 從 最 上 面 的 盤 子 搬 動 ( 二 ) 盤 子 可 以 搬 到 任 何 一 根 木 樁 ( 三 ) 維 持 盤 子 的 尺 寸 是 由 上 而 下 依 序 的 遞 增 n=1 在 木 樁 上 只 有 1 個 盤 子, 只 需 從 木 樁 1 搬 到 木 樁 3 即 可 n=2 在 木 樁 1 一 共 有 2 個 盤 子, 如 下 圖 所 示 : Step 1: 將 盤 子 從 木 樁 1 搬 移 到 木 樁 2, 如 下 圖 所 示 : Step 2: 將 盤 子 從 木 樁 1 搬 移 到 木 樁 3, 如 下 圖 所 示 : 50

53 Step 3: 將 盤 子 從 木 樁 2 搬 移 到 木 樁 3, 即 可 解 出 河 內 塔 問 題, 如 下 圖 所 示 : n=3 在 木 樁 1 上 一 共 有 3 個 盤 子, 如 下 圖 所 示 : Step 1: 將 盤 子 從 木 樁 1 搬 移 到 木 樁 3, 如 下 圖 所 示 : Step 2: 將 盤 子 從 木 樁 1 搬 移 到 木 樁 2, 如 下 圖 所 示 : Step 3: 將 盤 子 從 木 樁 3 搬 移 到 木 樁 2, 如 下 圖 所 示 : Step 4: 將 盤 子 從 木 樁 1 搬 移 到 木 樁 3, 如 下 圖 所 示 : 51

54 Step 5: 將 盤 子 從 木 樁 2 搬 移 到 木 樁 1, 如 下 圖 所 示 : Step 6: 將 盤 子 從 木 樁 2 搬 移 到 木 樁 3, 如 下 圖 所 示 : Step 7: 將 盤 子 從 木 樁 1 搬 移 到 木 樁 3, 即 可 完 成 河 內 塔 問 題, 如 下 圖 所 示 : 四 遞 迴 (recursion) 與 循 環 (iteration) ( 一 ) 差 異 1. 均 以 控 制 敘 述 為 基 礎 循 環 (Iteration): 重 複 結 構 (repetition structure) 遞 迴 (Recursion): 選 擇 結 構 (selection structure) 2. 均 包 含 重 複 性 (repetition) 循 環 (Iteration): 明 確 的 使 用 重 複 結 構 (repetition structure) 遞 迴 (Recursion): 重 複 進 行 函 數 呼 叫 (function calls) 3. 均 包 含 終 止 檢 驗 (termination test) 循 環 (Iteration): 迴 圈 - 終 止 檢 驗 (loop -termination test) 遞 迴 (Recursion): 基 本 狀 況 (base case) 4. 均 採 用 逐 步 接 近 終 止 法 (gradually approach termination) 循 環 (Iteration): 反 覆 修 改 計 數 器, 直 到 迴 圈 - 終 止 檢 驗 失 敗 (fail) 遞 迴 (Recursion): 產 生 逐 漸 簡 化 的 問 題 版 本 5. 均 可 能 發 生 無 窮 執 行 的 情 形 循 環 (Iteration): 當 迴 圈 - 終 止 檢 驗 永 遠 不 會 失 敗 (fail) 時 遞 迴 (Recursion): 當 遞 迴 步 驟 中 沒 有 簡 化 問 題 時 五 遞 迴 函 數 的 缺 點 ( 一 ) 過 多 重 複 的 函 數 呼 叫 : 因 為 函 式 會 重 複 呼 叫 自 己, 因 此 會 產 生 大 量 的 含 式 呼 叫, 這 對 處 理 器 的 計 算 時 間 和 記 憶 體 空 間 造 成 沈 重 負 擔 ( 二 ) 不 斷 產 生 新 函 數 呼 叫 而 消 耗 記 憶 體 : 每 次 遞 迴 呼 叫 都 會 產 生 新 的 函 式 變 數 和 活 動 記 錄, 這 會 消 耗 掉 可 觀 的 記 憶 體 因 此, 循 環 (Iteration) 通 常 在 函 式 中 進 行, 因 此 可 避 免 遞 迴 重 複 呼 叫 函 式 的 額 外 負 擔 含 額 外 的 記 憶 體 配 置 但 是, 我 們 可 能 為 了 要 配 合 軟 體 工 程 的 觀 點, 使 問 題 瞭 解 與 除 錯 更 容 易 而 選 擇 使 用 遞 迴 52

55 本 單 元 題 庫 1. 河 內 塔 (Hanoi) 問 題 : 有 三 根 柱 子 和 n 個 大 小 不 同 的 環 ( 如 圖 ) 欲 將 n 個 環 由 A 柱 移 到 B 柱 上, 移 動 規 則 如 下 : (1) 一 次 只 能 移 動 一 個 環 (2) 在 搬 移 的 過 程 中, 大 環 不 能 壓 住 小 環 問 : 最 少 移 動 次 數 及 搬 移 過 程 為 何? void hanoi(int n, int src, int dst, int tmp) if (n==1) printf( %d %d\n, src, dst); else hanoi(n-1, src, tmp, dst); printf( %d ( %d\n, src, dst); hanoi(n-1, tmp, dst, src); 輸 出 畫 面 Input:(n,A,B)=(3,1,3) Output: 移 動 次 數 :7 53

56 單 元 14: 物 件 概 念 (U14:Object concept) 一 何 謂 物 件 物 件 (Object) 是 一 個 抽 象 體 概 念 或 是 一 個 有 明 確 界 定 範 圍 的 事 物, 並 且 在 我 們 要 解 決 的 問 題 中 是 有 意 義 的 若 以 物 件 為 基 礎 的 軟 體 設 計 哲 學, 則 一 律 會 加 上 物 件 導 向 (Object Oriented, 簡 寫 為 OO) 的 名 稱 因 此 物 件 導 向 程 式 設 計 便 是 OOP (Object Oriented Programming ), 物 體 導 向 分 析 則 是 OOA(Object Oriented analysis), 物 件 導 向 程 式 語 言 則 是 OOPL(Object Oriented Programming Lagnage) 傳 統 的 軟 體 設 計 方 式 是 將 問 題 分 析 後, 採 取 適 當 的 資 料 結 構 來 表 示, 並 以 相 對 的 程 序 函 數 演 算 法 來 處 理 資 料 而 物 件 導 向 軟 體 設 計 則 以 物 件 將 相 關 的 資 料 和 程 序 結 合 成 一 體, 這 也 是 物 件 導 向 程 式 設 計 最 大 的 特 點 之 一 一 般 而 言, 物 件 導 向 程 式 設 計 具 有 以 下 3 種 特 性 : ( 一 ) 封 裝 (Encapsulation): 也 就 是 資 訊 隱 藏 (information hiding), 封 裝 是 將 資 料 和 處 理 資 料 的 程 序 與 函 數 組 合 起 來 建 立 物 件 封 裝 可 以 明 白 分 出 物 件 可 以 被 外 界 使 用 的 特 性 及 受 保 護 的 內 部 特 性 把 特 性 依 存 取 權 限 分 類 可 以 避 免 程 式 的 其 它 部 分 誤 用 此 物 件, 而 導 致 不 良 的 副 作 用 在 C++ 語 言 定 義 物 件 是 使 用 類 別 (Class), 內 含 屬 性 和 方 法, 屬 於 一 種 抽 象 資 料 型 態 (Abstract Data Type), 換 句 話 說, 就 是 替 程 式 語 言 定 義 新 的 資 料 型 態 透 過 封 裝, 其 它 物 件 僅 能 得 知 該 物 件 所 開 放 出 來 的 運 算 名 稱 (methods) 以 及 執 行 該 運 算 所 需 的 引 數 (arguments) 物 件 與 物 件 之 間 僅 能 藉 著 信 息 (message, 即 引 數 值 ) 的 傳 遞, 執 行 其 它 物 件 所 提 供 的 運 算 (method) 如 此 不 但 可 以 保 護 物 件 之 運 算 程 序 不 會 被 外 部 所 侵 擾, 也 可 以 使 程 式 設 計 模 組 化 (modularized) ( 二 ) 繼 承 (Inheritance): 繼 承 是 物 件 的 再 利 用, 當 定 義 好 一 個 類 別 後, 其 它 類 別 可 以 繼 承 這 個 類 別 的 資 料 和 方 法, 並 且 新 增 或 取 代 繼 承 物 件 的 資 料 和 方 法 繼 承 可 使 物 件 具 有 重 覆 使 用 性 (reusability), 而 繼 承 (inheritance) 則 是 達 成 重 覆 使 用 的 策 略 而 分 類 系 統 的 子 類 別 (sub-class) 會 繼 承 其 超 類 別 (super-class) 的 屬 性 屬 性 值 及 運 算 (operations, methods) 但 是, 子 類 別 可 以 有 自 己 特 殊 的 屬 性 ; 子 類 別 及 事 例 也 可 以 有 自 己 特 殊 的 屬 性 值 例 如 : 鳥 的 飛 行 屬 性 為 會, 其 子 類 別 老 鷹 綠 繡 眼 會 自 動 繼 承 此 一 屬 性 及 屬 性 值, 但 是 其 子 類 別 鷄 不 會 飛, 故 頇 特 別 指 明 其 飛 行 屬 性 為 否 分 類 系 統 的 子 類 別 ( 及 事 例 ) 和 超 類 別 為 是 一 種 (IsA) 的 關 係 例 如 : 老 鷹 是 一 種 鳥 ( 三 ) 多 形 (Polymorphism): 子 類 別 可 以 重 新 定 義 其 超 類 別 的 運 算 多 形 屬 於 物 件 導 向 最 複 雜 的 特 性, 類 別 如 果 需 要 處 理 各 種 不 同 資 料 型 態 時, 並 不 需 要 針 對 不 同 資 料 型 態 建 立 不 同 的 類 別, 可 以 直 接 繼 承 基 礎 類 別, 繼 承 此 類 別 建 立 同 名 方 法 處 理 不 同 的 資 料 型 態, 因 為 方 法 的 名 稱 相 同, 只 是 程 式 碼 不 同, 所 以 也 稱 為 同 名 異 式 例 如 : 整 數 為 實 數 的 子 類 別, 實 數 的 加 法 運 算 可 適 用 於 所 有 的 實 數, 但 是 整 數 加 法 可 以 重 新 加 以 定 義 其 僅 限 適 用 於 整 數 亦 即, 嚴 格 的 來 說, 實 數 和 整 數 的 加 法 運 算 分 別 對 應 不 同 的 資 料 型 態 ( 即 : 實 數 整 數 ), 但 是, 利 用 重 定 義 運 算 之 方 式, 可 以 讓 二 者 均 使 用 同 一 運 算 子 +, 以 簡 化 系 統 表 達 物 件 (Object) 是 物 件 導 向 技 術 的 關 鍵, 以 程 式 的 角 度 來 說, 物 件 是 資 料 與 相 關 程 序 和 函 數 結 合 在 一 起 的 組 合 體, 資 料 是 變 數, 程 序 和 函 數 在 C++ 語 言 稱 為 方 法, 如 右 圖 所 示 : 右 方 圖 例 的 方 法 是 對 外 的 使 用 介 面, 變 數 和 方 法 都 包 裹 在 一 個 黑 盒 子, 同 學 所 撰 寫 與 實 作 的 程 式 碼 都 被 包 裹 隱 藏 起 來, 稱 為 封 裝 (Encapsulation) 對 於 程 式 設 計 者 來 說, 我 們 並 不 用 考 慮 黑 盒 子 內 部 54

57 的 程 式 碼 是 如 何 撰 寫, 只 需 要 知 道 這 個 物 件 提 供 什 麼 介 面 和 如 何 使 用 它 物 件 擁 有 3 種 特 性, 以 汽 車 為 例 : ( 一 ) 狀 態 (State): 物 件 所 有 屬 性 (Attributes) 目 前 的 狀 態 值, 屬 性 是 用 來 儲 存 物 件 的 狀 態, 可 以 簡 單 的 只 是 一 個 布 林 值 變 數, 也 可 能 是 另 一 個 物 件, 例 如 : 車 子 的 車 型 排 氣 量 色 彩 和 自 排 或 手 排 等 屬 性 ( 二 ) 行 為 (Behavior): 行 為 是 物 件 可 見 部 分 提 供 的 服 務, 可 以 作 什 麼 事, 例 如 : 車 子 可 以 發 動 停 車 加 速 和 換 擋 等 ( 三 ) 識 別 字 (Identity): 識 別 字 是 用 來 識 別 不 同 的 物 件, 每 一 個 物 件 都 擁 有 獨 一 無 二 的 識 別 字, Java 語 言 是 使 用 物 件 參 考 (Reference) 作 為 物 件 的 識 別 字, 簡 單 的 說, 就 是 物 件 實 際 儲 存 的 記 憶 體 位 址, 詳 細 的 說 明 請 參 閱 第 節 二 物 件 間 的 關 係 物 件 之 間 的 主 要 關 係 主 要 包 括 以 下 三 種 : ( 一 ) 鏈 結 (Links): 假 定 現 在 有 二 個 物 件 案 例 (instance), 一 位 是 游 老 師, 一 位 是 張 同 學 若 游 老 師 與 張 同 學 之 間 存 在 教 學 的 關 係, 則 游 老 師 教 導 張 同 學 反 過 來 看, 張 同 學 則 受 教 於 游 老 師, 這 兩 個 案 例 間 的 關 係 便 是 鏈 結 ( 二 ) 關 聯 (Associations): 事 實 上 全 校 師 生 眾 多, 因 此 老 師 可 能 有 多 位, 同 學 也 可 能 有 多 位, 因 此 將 游 老 師 與 張 同 學 的 兩 個 案 例 一 般 化 後, 我 們 得 到 兩 個 單 純 抽 象 的 類 別, 分 別 是 老 師 類 別 (class teacher) 及 同 學 類 別 (class student) 各 同 學 與 各 老 師 之 間 鏈 結 的 集 合 便 稱 為 關 聯 (associations) 也 就 是 說, 鏈 結 是 真 實 世 界 中 物 件 的 關 係, 而 是 將 鏈 結 抽 象 化, 一 般 化 後 我 們 便 可 得 到 關 聯 (association) ( 三 ) 聚 合 (aggregation): 一 些 物 件 可 以 組 成 另 一 種 物 件, 用 以 表 明 一 種 物 件 組 成 的 關 係, 例 如 車 子 ( 物 件 ) 是 由 輪 子 引 擎 方 向 盤 等 各 種 物 件 所 組 成 的, 它 們 之 間 是 構 件 (part_of) 的 關 係 如 果 A 物 件 是 B 元 件 的 一 部 分,B 物 件 是 C 物 件 的 一 部 分, 則 B 物 件 亦 會 是 C 物 件 的 一 部 分 則 A 物 件 是 C 物 件 的 一 部 分 A 物 件 是 B 物 件 的 一 部 分 則 B 物 件 必 非 A 物 件 之 一 部 分 ( 四 ) 一 般 化 (Generalization): 由 性 質 相 同 的 子 類 別 定 義 出 超 類 別, 是 一 個 由 下 而 上 的 過 程 ( 五 )Specialization ( 特 殊 化 ): 從 超 類 別 定 義 出 特 殊 子 類 別, 是 一 個 由 上 而 下 的 衍 生 過 程 55

58 單 元 15: 類 別 (U15:Classes) 一 類 別 定 義 對 於 具 有 類 似 性 質 相 同 的 行 為 意 義 及 共 同 關 係 的 物 件 之 描 述 即 為 類 別 簡 單 的 說, 類 別 即 是 具 相 同 性 質 物 件 的 集 合 ; 反 之, 對 於 類 別 而 言, 物 件 則 為 其 案 例 (instance) 二 多 載 (Override) 若 父 類 別 的 方 法 並 不 符 合 子 類 別 的 需 求, 我 們 可 以 在 子 類 別 宣 告 同 名 同 參 數 列 和 傳 回 值 的 方 法 來 取 代 父 類 別 的 方 法, 稱 為 多 載 ( Override) 不 過, 物 件 的 實 例 方 法 並 不 能 取 代 類 別 方 法 ( 宣 告 成 static 的 方 法 ), 如 果 父 類 別 擁 有 類 別 方 法, 子 類 別 需 要 宣 告 同 樣 的 類 別 方 法 來 取 代 它, 稱 為 隱 藏 (Hide), 覆 寫 和 隱 藏 的 差 異, 如 下 表 所 示 : 父 類 別 的 實 例 方 法 父 類 別 的 類 別 方 法 子 類 別 的 實 例 方 法 覆 寫 編 譯 錯 誤 子 類 別 的 類 別 方 法 編 譯 錯 誤 隱 藏 三 類 別 使 用 域 類 別 使 用 域 (class scope) 包 含 了 類 別 的 資 料 成 員 (data members) 及 成 員 函 式 (member functions), 而 非 成 員 函 數 則 屬 於 檔 案 使 用 域 (file scope) 在 類 別 使 用 域 中, 類 別 的 所 有 成 員 可 透 過 成 員 函 數 存 取, 且 可 透 過 名 稱 參 照 在 類 別 使 用 域 外, 則 需 藉 由 物 件 的 代 表 (handle) 進 行 參 照 ( 一 ) 資 料 成 員 : 變 數 在 類 別 定 義 中 被 宣 告 ( 二 ) 成 員 函 式 : 函 式 在 類 別 定 義 中 被 宣 告 四 成 員 函 數 多 載 與 成 員 選 擇 運 算 子 成 員 函 數 可 以 多 載, 但 多 載 後 的 成 員 函 數 仍 為 成 員 函 數 要 多 載 成 員 函 數, 只 需 在 類 別 定 義 內 列 出 每 個 多 載 函 數 的 原 理, 再 為 它 們 提 供 定 義 即 可 在 成 員 函 式 中 定 義 了 一 個 變 數, 其 名 稱 與 另 一 個 類 別 使 用 域 的 變 數 名 稱 相 同, 則 在 此 函 式 使 用 域 中, 類 別 使 用 域 的 變 數 會 被 隱 藏 將 點 號 成 員 選 擇 運 算 子 ( ), 置 於 物 件 名 稱 或 指 向 物 件 的 參 照 之 後, 可 以 存 取 該 物 件 的 成 員 箭 號 成 員 選 擇 運 算 子 (->) 可 配 合 指 向 物 件 的 指 標, 存 取 該 物 件 的 成 員 五 標 頭 檔 與 工 具 函 數 標 頭 檔 包 含 部 分 實 作 程 式 碼, 以 及 和 其 他 部 分 有 關 的 提 示 例 如, 行 內 成 員 函 數 式 必 頇 置 於 標 頭 檔 中, 讓 編 譯 器 編 譯 外 部 程 式 時, 直 接 在 需 要 處 插 入 行 內 成 員 函 式 的 自 訂 定 義 標 頭 檔 中 的 類 別 定 議 會 列 出 類 別 的 private 成 員 ; 使 用 者 雖 然 無 法 存 取 它 們, 但 仍 舊 可 藉 此 得 知 成 員 的 相 關 訊 息 工 具 函 式 又 稱 為 助 手 函 式, 是 用 來 幫 助 類 別 其 他 public 成 員 函 數 完 成 工 作 的 private 函 式, 不 能 被 外 部 程 式 使 用 它 與 一 般 函 式 相 同, 建 構 子 可 以 擁 有 預 設 引 數 而 當 物 件 消 滅 時, 系 統 會 自 動 呼 叫 其 類 別 的 解 構 子 六 建 構 子 與 解 構 子 類 別 解 構 子 的 名 稱, 是 類 別 名 稱 前 面 加 上 波 浪 符 號 (~) 一 般 而 言, 解 構 子 不 會 釋 放 物 件 的 儲 存 空 間, 它 會 在 系 統 收 回 物 件 所 佔 記 憶 體 前, 執 行 資 源 回 收, 讓 新 物 件 得 以 利 用 清 出 來 的 記 憶 體 解 構 子 不 接 收 任 何 參 數, 也 沒 有 傳 回 值, 每 個 類 別 最 多 可 擁 有 一 個 解 構 子 若 程 式 設 計 56

59 者 未 指 定 類 別 解 構 子, 編 譯 器 會 自 動 提 供, 所 以 每 個 類 別 都 會 有 解 構 子 解 構 子 和 解 構 子 的 呼 叫 順 序, 與 建 構 子 的 呼 叫 順 序 相 反, 但 物 件 的 儲 存 類 別 會 改 變 這 些 順 序 七 預 設 逐 成 員 指 定 (Default Memberwise Assignment) 指 向 物 件 的 參 照, 相 當 於 其 名 稱 的 別 名, 因 此 可 用 在 指 定 敘 述 的 左 邊, 接 受 設 定 的 數 值 在 此 情 形 下, 參 照 會 做 lvalue, 接 受 要 設 定 的 數 值 指 定 運 算 子 (=) 可 將 某 個 物 件 指 定 給 另 一 個 相 同 型 別 的 物 件 預 設 情 況 下, 此 操 作 會 進 行 逐 成 員 複 製 (memberwise copy), 將 指 定 運 算 子 右 邊 物 件 的 每 個 成 員, 逐 一 設 給 左 邊 物 件 的 每 個 成 員 而 物 件 可 以 作 為 引 數 傳 給 函 式, 也 可 以 從 函 式 傳 回 傳 遞 與 傳 回 預 設 以 傳 值 呼 叫 進 行, 即 程 式 會 傳 回 物 件 的 副 本 因 此,C++ 會 建 立 新 的 物 件, 透 過 複 製 建 構 子 (copy constructor) 將 原 物 件 的 值 設 給 新 的 物 件 八 Const 物 件 與 Const 成 員 函 式 關 鍵 字 const 可 用 來 指 定 物 件 不 可 被 修 改, 程 式 若 詴 圖 修 改 物 件 內 容, 則 會 產 生 編 譯 錯 誤 C++ 編 譯 器 不 允 許 在 const 物 件 上 呼 叫 非 const 成 員 函 式, 而 const 成 員 函 式 若 詴 圖 修 改 其 類 別 的 物 件 (*this), 則 會 造 成 編 譯 錯 誤 當 函 式 為 const 時, 必 頇 在 原 型 和 定 義 中 都 寫 出 const, 而 且 const 物 件 需 要 在 初 始 化 時 指 定 內 容 值, 不 能 於 產 生 後 才 賦 予 內 容 值 有 一 個 需 要 注 意 的 部 分 是, 建 構 子 與 解 構 子 不 能 宣 告 為 const 而 const 資 料 成 員 與 參 照 資 料 成 員 必 頇 透 過 成 員 初 始 值 設 定 預 設 值 九 組 合 類 別 可 以 擁 有 其 他 類 別 的 物 件 做 為 成 員, 這 種 概 念 稱 之 為 組 合 (Composition) 成 員 物 件 按 照 它 們 在 類 別 定 義 中 的 順 序 進 行 建 構, 並 且 比 包 含 它 們 的 類 別 物 件 更 先 建 立 未 提 供 成 員 初 始 值 給 成 員 物 件 時, 系 統 會 自 動 呼 叫 該 物 件 的 預 設 建 構 子 十 夥 伴 函 式 (friend Functions) 與 夥 伴 類 別 (friend Classes) 類 別 的 夥 伴 函 式 定 義 於 類 別 範 圍 的 外 部, 它 可 以 存 取 類 別 的 非 public 成 員 函 式 或 整 個 類 別 可 以 宣 告 成 另 一 個 類 別 的 夥 伴 夥 伴 宣 告 可 以 寫 在 類 別 的 任 何 地 方, 而 夥 伴 其 實 是 類 別 public 介 面 的 一 部 份 夥 伴 關 係 沒 有 對 稱 性, 也 沒 有 轉 移 性 十 一 使 用 this 指 標 所 有 物 件 都 可 以 透 過 this 指 標 存 取 自 己 的 位 址 空 間, 物 件 的 this 不 是 物 件 自 己 的 一 部 份, 這 也 就 是 說 若 對 this 執 行 sizeof 運 算 的 結 果, 與 對 物 件 執 行 sizeof 運 算 的 結 果 不 同 編 譯 器 會 將 this 指 標 作 為 隱 含 的 引 數 傳 給 物 件 的 非 static 成 員 函 式 物 件 會 自 動 使 用 this 指 標, 也 可 以 明 確 使 用 此 指 標 以 參 照 其 資 料 成 員 與 成 員 函 式 透 過 this 指 標, 我 們 能 在 單 一 敘 述 中 藉 著 連 續 成 員 函 式 呼 叫 多 個 函 式 十 二 動 態 記 憶 體 配 置 程 式 設 計 者 能 透 過 動 態 記 憶 體 管 理, 針 對 任 何 內 建 的 型 別 或 使 用 者 自 訂 型 別, 進 行 記 憶 體 的 配 置 和 清 除 自 由 儲 存 空 間 ( 又 稱 為 推 積 ) 是 配 發 給 程 式 的 記 憶 體 區 塊, 作 為 執 行 期 動 態 儲 存 物 件 之 用 關 於 記 憶 體 配 置 的 運 算 子 主 要 有 new 及 delete 運 算 子 ( 一 ) new 運 算 子 : 運 算 子 new 能 為 物 件 配 置 適 當 的 記 憶 體 空 間, 直 型 物 件 的 建 構 子, 並 傳 回 正 確 型 別 的 指 標 而 new 可 以 動 態 配 置 各 種 型 別 ( 如 int 或 double) 或 類 別 型 別 如 果 new 無 法 為 物 件 在 記 憶 體 中 找 到 可 用 的 空 間, 則 為 拋 出 例 外, 指 出 發 生 了 錯 誤 通 常 這 會 讓 程 式 立 刻 停 止 執 行 ( 二 ) delete 運 算 子 : 可 以 清 除 物 件 且 釋 放 它 所 佔 用 的 記 憶 體 空 間 57

60 記 憶 體 配 置 說 明 物 件 陣 列 可 以 藉 由 以 下 方 式, 使 用 new 運 算 子 進 行 動 態 配 置 : int *ptr = new int[100]; 以 上 敘 述 會 配 置 一 個 具 有 100 個 整 數 的 陣 列, 且 將 陣 列 的 起 始 位 址 指 定 給 ptr 這 個 整 數 陣 列 可 以 用 以 下 敘 述 清 除 : delete [] ptr; 十 三 static 類 別 成 員 static 資 料 成 員 代 表 全 類 別 共 用 的 資 訊, 意 思 是 類 別 所 有 物 件 共 通 的 特 性, 而 非 特 定 物 件 的 個 別 屬 性 static 資 料 成 員 具 有 類 別 使 用 域, 且 可 宣 告 為 public private 或 protected 即 使 類 別 沒 有 任 何 物 件 存 在, 該 類 別 的 static 成 員 仍 然 存 在 類 別 沒 有 物 件 存 在 時, 若 要 存 取 其 public static 成 員, 只 要 在 成 員 名 稱 前 面 寫 出 類 別 名 稱 後 接 雙 原 使 用 域 解 析 運 算 子 (::) 即 可 程 式 可 透 過 該 類 別 的 任 何 物 件, 存 取 類 別 的 public static 成 員 成 員 函 式 若 不 存 取 類 別 的 非 static 資 料 成 員 或 成 員 函 式, 則 應 宣 告 為 static Static 成 員 函 式 沒 有 this 指 標, 因 為 static 資 料 成 員 與 成 員 函 式 獨 立 存 在 於 任 何 類 別 物 件 之 外 十 四 代 理 類 別 代 理 類 別 只 知 道 自 訂 類 別 的 public 介 面, 讓 外 界 使 用 者 得 以 運 用 自 訂 類 別 提 供 的 服 務, 但 不 能 存 取 類 別 的 實 作 細 節 類 別 定 義 只 用 到 指 向 其 他 類 別 的 指 標 或 參 照 時, 不 需 用 #include 指 令 加 入 該 類 別 的 標 頭 檔 只 需 在 使 用 該 類 別 之 前, 使 用 前 置 類 別 宣 告, 將 該 類 別 宣 告 成 一 個 資 料 型 別 即 可 代 理 類 別 的 成 員 函 式 實 作 檔 案, 是 唯 一 包 含 類 別 標 頭 檔 的 檔 案, 而 此 類 別 的 private 資 料 就 是 我 們 想 要 隱 藏 的 資 料 代 理 類 別 的 成 員 函 式 實 作 檔, 是 以 預 先 編 譯 過 的 目 的 檔 格 式 提 供 給 用 戶 端, 此 時 內 涵 代 理 函 式 成 員 原 型 的 標 頭 檔 也 頇 一 併 提 供 [ 範 例 ] 先 宣 告 一 個 空 白 的 類 別, 類 別 名 稱 為 MyFirstClass, 並 且 使 用 這 個 類 別 來 建 立 一 個 物 件 程 式 碼 FileName:EmptyClass.cpp 01 #include <cstdlib> 02 #include <iostream> using namespace std; 05 // 定 義 類 別, 名 稱 為 MyFirstClass 06 class MyFirstClass ; int main(int argc, char *argv[]) cout << " 宣 告 一 個 MyFirstClass 物 件 A...\n"; 13 MyFirstClass A ; 14 cout << "A 物 件 建 立 完 成!!\n"; 16 system("pause"); 17 return EXIT_SUCCESS; 18 58

61 單 元 16: 資 料 抽 象 化 (U16:Data abstraction) 一 抽 象 資 料 化 抽 象 資 料 型 別 是 電 腦 系 統 將 真 實 世 界 表 達 到 某 種 精 確 度 的 方 式, 抽 象 化 的 機 制 可 以 簡 化 複 雜 的 觀 念 或 事 物, 常 見 的 有 資 料 抽 象 化 (data abstraction) 與 控 制 抽 象 化 (control abstraction) 副 程 式 (subroutine) 是 達 成 控 制 抽 象 化 (control abstraction) 的 一 種 機 制, 呼 叫 的 敘 述 (caller) 利 用 副 程 式 的 名 稱 來 進 行 呼 叫, 然 後 等 待 副 程 式 完 成 執 行, 呼 叫 的 敘 述 提 供 的 參 數 稱 為 實 際 參 數 (actual parameters, 或 稱 arguments), 副 程 式 對 應 的 參 數 叫 做 正 式 參 數 (formal parameters) 資 訊 隱 藏 (information hiding), 也 就 是 物 件 的 封 裝 性 (encapsulation), 可 以 明 白 分 出 物 件 可 以 被 外 界 使 用 的 特 性 及 受 保 護 的 內 部 特 性 把 特 性 依 存 取 權 限 分 類 可 以 避 免 程 式 的 其 它 部 分 誤 用 此 物 件, 而 導 致 不 良 的 副 作 用 二 物 件 導 向 程 式 設 計 的 特 性 抽 象 化 (Abstraction) 封 裝 (Encapsulation) 繼 承 (Inheritance) 多 形 (Polymorphism) 動 態 繫 結 (Dynamic binding) 59

62 單 元 17: 運 算 子 多 載 (U17:Operator Overloading) 一 運 算 子 多 載 C++ 使 程 式 設 計 者 能 多 載 大 部 分 運 算 子, 使 這 些 運 算 子 對 它 們 所 處 理 的 程 式 上 下 文 變 得 更 敏 銳, 編 譯 器 將 根 據 程 式 的 上 下 文 產 生 適 當 的 程 式 碼 許 多 C++ 運 算 子 可 以 在 多 載 後, 用 來 處 理 使 用 者 自 訂 型 別 內 建 於 C++ 的 一 個 多 載 運 算 子 的 例 子 就 是 <<, 這 個 運 算 子 可 以 同 時 作 為 串 流 插 入 運 算 子 和 逐 位 元 左 移 運 算 子 同 樣 的,>> 運 算 子 也 經 過 多 載, 它 可 以 做 為 串 流 擷 取 運 算 子 和 右 移 運 算 子 在 C++ 的 類 別 函 式 庫 中, 這 兩 個 運 算 子 都 已 經 加 以 多 載 過 了 C++ 語 言 本 身 也 多 載 了 + 和 - 運 算 子 依 據 這 兩 個 運 算 子 在 整 數 算 數 浮 點 數 算 術 指 標 算 數 的 程 式 上 下 文, 它 會 執 行 不 同 的 操 作 多 載 運 算 子 所 執 行 的 工 作, 也 可 以 透 過 明 確 的 函 式 呼 叫 來 加 以 執 行, 但 是 以 運 算 子 來 表 示 它, 對 程 式 設 計 者 會 比 較 清 楚, 也 更 成 熟 二 多 載 運 算 方 式 多 載 運 算 的 方 式 為, 寫 出 其 非 static 成 員 函 式 定 義 或 全 域 函 式 定 義, 函 式 名 稱 則 是 關 鍵 字 operator, 其 後 跟 隨 著 要 多 載 的 運 算 子 符 號 當 我 們 將 運 算 子 多 載 為 成 員 函 式 時, 它 們 必 頇 是 非 static 的, 這 是 因 為 它 們 必 頇 被 針 對 所 屬 類 別 的 物 件 來 進 行 呼 叫, 並 且 對 該 物 件 加 以 操 作 若 要 將 某 個 運 算 子 運 用 在 類 別 物 件 上, 則 此 運 算 子 必 頇 加 以 多 載, 不 過 有 三 個 運 算 子 例 外, 它 們 分 別 是 : 指 定 運 算 子 (=) 取 址 運 算 子 (&) 和 逗 點 運 算 子 (,) 三 運 算 子 多 載 的 限 制 運 算 子 多 載 的 限 制 主 要 包 括 如 下 : ( 一 ) 無 法 藉 由 多 載 的 方 式, 改 變 運 算 子 的 優 先 權 和 結 合 性 ( 二 ) 無 法 改 變 運 算 子 的 元 數 (arity), 也 就 是 運 算 子 能 接 受 的 運 算 元 數 量 ( 三 ) 無 法 建 立 新 的 運 算 子 ( 四 ) 只 有 現 存 的 運 算 子 可 以 多 載 ( 五 ) 無 法 改 變 運 算 子 對 內 建 型 別 物 件 進 行 操 作 時 的 意 義 ( 六 ) 對 一 個 類 別 的 指 定 運 算 子 和 加 法 運 算 子 予 以 多 載, 並 不 意 味 著 運 算 子 += 也 已 經 被 多 載 了, 我 們 必 頇 明 確 多 載 該 類 別 的 += 運 算 子, 才 能 使 用 這 項 功 能 四 運 算 子 函 式 做 為 類 別 成 員 與 全 域 成 員 運 算 子 函 式 可 以 是 成 員 函 式 或 是 全 域 函 式, 當 它 是 全 域 函 式 時, 為 了 考 量 效 能, 通 常 會 做 成 friend 成 員 函 式 使 用 this 指 標, 隱 喻 地 取 得 其 類 別 物 件 的 其 中 一 個 引 數 ( 對 二 元 運 算 子 而 言 是 左 引 數 ) 用 於 二 元 運 算 子 兩 個 運 算 元 的 引 數, 必 頇 明 確 的 列 舉 在 全 域 函 式 中 在 多 載 () [] -> 或 任 何 指 定 運 算 子 的 時 候, 其 多 載 的 運 算 子 函 數 必 需 宣 宣 告 類 別 成 員 對 於 其 它 運 算 子, 其 多 載 的 運 算 子 函 數 可 以 是 成 員 函 數 或 全 域 函 數 當 運 算 子 函 式 實 作 為 成 員 函 數 時, 最 左 邊 或 唯 一 的 運 算 元 必 頇 是 該 運 算 子 所 屬 類 別 的 物 件 或 是 指 向 物 件 的 參 照 如 果 左 運 算 元 必 頇 是 不 同 類 別 的 物 件, 或 者 必 頇 是 內 建 基 本 型 的 物 件, 則 這 個 運 算 子 函 式 必 頇 實 作 成 全 域 函 式 如 果 一 個 全 域 運 算 子 函 式 必 頇 直 接 存 取 某 一 類 別 的 private 或 protected 成 員, 則 該 函 式 必 頇 成 為 這 類 別 的 friend 五 串 流 插 入 與 串 流 擷 取 的 多 載 多 載 的 串 流 插 入 運 算 子 (<<) 用 於 左 運 算 元 具 有 ostream & 型 別 的 運 算 式 中 基 於 這 個 原 因, 它 必 頇 多 載 成 全 域 函 數 如 果 要 它 成 為 成 員 函 式, 則 運 算 子 << 就 必 頇 是 類 別 ostream 的 60

63 成 員, 但 這 是 不 可 能 的, 因 為 我 們 不 允 許 修 改 C++ 標 準 函 式 庫 類 別 同 樣 地, 多 載 的 串 流 擷 取 運 算 子 (>>) 也 必 頇 是 全 域 函 式 選 擇 將 運 算 子 多 載 成 全 域 的 另 一 個 理 由 是 能 讓 運 算 子 有 交 換 性 在 與 cin 和 string 搭 配 使 用 的 時 候,setw 可 以 藉 著 其 引 數, 將 讀 入 的 字 元 個 數 限 制 在 該 引 數 所 指 明 的 字 元 個 數 類 別 istream 的 成 員 函 式 ignore 會 捨 棄 在 輸 入 串 流 中, 以 及 經 過 指 明 的 字 元 個 數 基 於 效 率 考 量, 如 果 多 載 的 術 入 運 算 子 和 輸 出 運 算 子 需 要 直 接 存 取 非 public 的 類 別 成 員, 則 必 頇 將 它 們 宣 告 成 friend 函 式 六 多 載 運 算 子 ( 一 ) 多 載 一 元 運 算 子 類 別 的 一 元 運 算 子 可 以 多 載 成 不 具 引 數 的 非 static 成 員 函 式, 或 是 具 有 一 個 引 數 的 全 域 函 式 該 引 數 必 頇 是 此 類 別 的 物 件 或 指 向 該 類 別 物 件 的 參 照 用 於 實 作 多 載 運 算 子 的 成 員 函 式, 必 頇 是 非 static, 如 此 它 們 才 能 存 取 所 屬 類 別 的 每 一 個 物 件 中 的 非 static 資 料 ( 二 ) 多 載 二 元 運 算 子 二 元 運 算 子 可 以 多 載 成 具 有 一 個 引 數 的 非 static 成 員 函 式, 或 具 有 兩 個 引 數 的 全 域 函 式 七 不 同 型 別 間 的 轉 換 編 譯 器 無 法 預 知 如 何 在 不 同 使 用 者 自 訂 的 型 別 間, 以 及 使 用 者 自 訂 型 別 和 內 建 型 別 間 進 行 轉 換, 所 以 程 式 設 計 者 必 頇 詳 細 指 明 如 何 執 行 這 項 操 作 我 們 可 以 使 用 轉 型 建 構 子 (conversion constructor) 來 執 行 這 類 的 轉 換, 所 謂 轉 型 建 構 子 是 一 種 單 引 數 建 構 子, 它 可 以 將 其 它 型 別 ( 包 含 內 建 型 別 ) 的 物 件 轉 換 成 特 定 類 別 的 物 件 轉 型 運 算 子 也 稱 為 強 制 轉 型 運 算 子 (cast operator), 它 可 以 將 一 個 類 別 的 物 件 轉 換 成 令 一 個 類 別 的 物 件, 或 者 轉 換 為 內 建 型 別 的 物 件 這 樣 的 轉 型 運 算 子 必 頇 是 非 static 成 員 函 式 多 載 的 強 制 轉 型 運 算 子 函 式 可 以 定 義 為 將 使 用 者 自 訂 型 別 的 物 件, 轉 換 成 內 建 型 別 的 物 件, 或 轉 換 成 其 他 使 用 者 自 訂 型 別 的 物 件 多 載 的 強 制 轉 換 型 別 運 算 子 函 式 (cast operator fuction) 並 沒 有 指 定 傳 回 的 型 別, 其 中 傳 回 的 型 別 就 是 此 物 件 所 要 轉 換 成 的 型 別 強 制 轉 型 運 算 子 和 轉 型 建 構 子 很 好 的 一 項 功 能 是, 在 需 要 的 時 候, 編 譯 器 可 以 呼 叫 這 些 函 式 來 隱 喻 地 建 立 暫 時 的 物 件 而 任 何 單 一 引 數 建 構 子 (single-argument constructor) 都 可 以 是 為 轉 型 建 構 子 對 函 式 呼 叫 運 算 子 () 予 以 多 載 是 很 強 而 有 力 的 功 能, 因 為 此 時 函 式 就 能 夠 接 受 任 意 長 度 和 複 雜 的 參 數 列 此 外, 前 置 和 後 置 遞 增 和 遞 減 運 算 子 都 能 加 以 多 載 [ 範 例 ] 希 望 car 類 別 中 的 Accelerate 方 法 能 有 多 種 加 速 方 式 如 : Accelerate(); // 速 度 加 1 Accelerate(50) ; // 速 度 加 50 Accelerate( STOP ) // 停 車 這 時 上 述 兩 種 Accelerate 方 法 的 參 數 個 數 與 型 別 不 一 樣, 可 用 方 法 多 載 (Overloading) 來 達 成 61

64 程 式 碼 FileName:Overloading-1.cpp 01 #include <cstdlib> 02 #include <iostream> 04 using namespace std; 05 class Car private: 08 int _speed ; public: 11 int GetSpeed () return _speed; void SetSpeed(int value) if (value < 0) value = 0; if (value > 200) value = 200; _speed = value; void Accelerate() this->_speed++; void Accelerate(int addspeed) this->_speed += addspeed; void Accelerate(string S) 39 if (S == "STOP") 40 this->_speed = 0; ; int main(int argc, char *argv[]) 46 62

65 47 Car Benz; 48 Benz.SetSpeed (0); 49 cout << " 現 在 速 度 :" << Benz.GetSpeed() << endl; 50 cout << " 加 速...\n"; 51 Benz.Accelerate(); 52 cout << " 現 在 速 度 :" << Benz.GetSpeed() << endl; 53 cout << " 加 速 10...\n"; 54 Benz.Accelerate(10); 55 cout << " 現 在 速 度 :" << Benz.GetSpeed() << endl; 56 cout << " 停 車...\n"; 57 Benz.Accelerate("STOP"); 58 cout << " 現 在 速 度 :" << Benz.GetSpeed() << endl; 59 system("pause"); 60 return EXIT_SUCCESS; 61 63

66 單 元 18: 繼 承 (U18:Inheritance) 一 繼 承 的 概 念 繼 承 可 使 物 件 具 有 重 覆 使 用 性 (reusability), 而 繼 承 (inheritance) 則 是 達 成 重 覆 使 用 的 策 略 由 生 物 學 的 觀 點 來 看 繼 承, 子 代 的 特 徵 都 來 自 於 親 代 由 電 腦 的 觀 點 來 看 繼 承, 繼 承 就 是 類 似 軟 體 元 件 共 用, 並 且 分 享 相 同 的 行 為 以 及 相 似 的 特 性 或 運 作 一 個 被 繼 承 的 父 類 別 (parent class ), 通 常 被 稱 為 超 類 別 (super class) 而 子 類 別 (child class) 則 被 稱 為 副 類 別 (subclass) 父 類 別 和 子 類 別 之 間 則 存 在 有 一 般 化 關 係 (Generalization), 而 同 時 也 是 表 示 is-a 或 a-kind-of 的 關 係 因 此 子 類 別 的 案 例 (instance) 同 時 也 必 頇 是 父 類 別 的 案 例 繼 承 (Inheritance) 是 物 件 導 向 程 式 設 計 的 重 要 觀 念, 繼 承 是 一 個 類 別 含 括 現 存 類 別 的 部 分 或 全 部 的 成 員 資 料 和 成 員 方 法, 並 且 新 增 額 外 的 成 員 資 料 或 方 法, 或 是 覆 寫 或 隱 藏 繼 承 類 別 的 方 法 或 變 數 當 一 個 類 別 是 繼 承 自 其 它 類 別, 我 們 稱 這 個 類 別 為 繼 承 類 別 的 子 類 別 (Subclass) 或 延 伸 類 別 (Derived Class), 繼 承 的 類 別 稱 為 父 類 別 (Superclass) 或 基 礎 類 別 (Base Class) 例 如 : 類 別 Nissan 是 繼 承 自 類 別 Car, 繼 承 關 係 如 下 圖 所 示 : 上 述 圖 例 是 UML 類 別 圖, 使 用 空 心 箭 頭 線 標 示 類 別 間 的 繼 承 關 係 類 別 Car 是 類 別 Nissan 的 父 類 別, 反 之, 類 別 Nissan 是 類 別 Car 的 子 類 別 如 果 有 多 個 子 類 別 繼 承 同 一 個 父 類 別, 每 一 個 子 類 別 稱 為 兄 弟 類 別 (Sibling Classes), 如 下 圖 所 示 : 上 述 圖 例 的 類 別 Truck Car 和 Motocycle 是 兄 弟 類 別 當 然 還 可 以 再 繼 承 類 別 Car, 類 別 Nissan 也 是 類 別 Vehicle 的 子 類 別, 不 過 並 不 是 直 接 繼 承 的 子 類 別 64

67 二 繼 承 的 範 例 由 於 子 類 別 可 繼 承 父 類 別 的 某 些 特 性, 因 此 對 於 家 族 族 譜 而 言, 後 代 子 孫 有 可 能 會 繼 承 爸 爸 及 祖 父 的 姓 氏 外 型 特 徵 住 址 電 話 等 若 以 幾 何 圖 形 來 說 明, 正 方 形 可 以 繼 承 四 邊 形 與 矩 形 的 特 性, 例 如 四 邊 行 的 求 面 積 公 式 ( 長 X 寬 ) 可 以 被 延 用 至 後 代 用 C++ 來 描 述 族 譜 的 繼 承 class GrandFather 姓, 名, 血 型, 住 址, 電 話, class Father : public GrandFather class Son : public Father 用 C++ 來 描 述 幾 何 形 狀 的 繼 承 class Shape class Rectangle : public Shape class Square : public Rectangle 三 繼 承 的 方 式 class Animal public : int Life; int canmove(); ; class Mammal : public Animal public : int Milk; ; 65

68 #include <iostream.h> // 矩 形 class Rectangle public : int nlength; int nwidth; int Area() return nlength * nwidth; ; // 正 方 形 class Square : public Rectangle public : int Area() return nlength * nlength; ; // 主 程 式 void main() Square a; a.nlength = 5; cout << a.area() << endl; 四 繼 承 的 等 級 ( 一 )Public class A private : int nprivate; protected : int nprotected; public : int npublic; class B : public A class C : public C ( 二 )Protected class A private : int nprivate; protected : int nprotected; public : int npublic; class B : protected A class C : protected C 66

69 ( 三 )Private class A private : int nprivate; protected : int nprotected; public : int npublic; class B : private A class C : private C 五 繼 承 存 取 權 限 的 存 取 限 制 class 子 類 別 : 繼 承 存 取 權 限 1 父 類 別 1, // 子 類 別 繼 承 自 父 類 別 繼 承 存 取 權 限 1 父 類 別 2, 繼 承 存 取 權 限 N 父 類 別 N ; public 若 繼 承 存 取 權 限 為 public, 則 父 類 別 的 private 成 員 無 法 允 許 在 子 類 別 中 使 用, 只 有 public 及 protected 成 員 允 許 在 子 類 別 中 使 用 ; 子 類 別 的 public 成 員 允 許 外 界 存 取,private 及 protected 成 員 無 法 允 許 外 界 存 取 此 種 繼 承 存 取 權 限 是 最 常 使 用 方 式 之 一 private 若 繼 承 存 取 權 限 為 private, 則 父 類 別 的 private 成 員 無 法 在 子 類 別 中 使 用,public 及 protected 成 員 允 許 在 子 類 別 中 使 用 ; 但 子 類 別 的 public private 及 protected 成 員 無 法 允 許 外 界 存 取 protected 若 繼 承 存 取 權 限 為 protected, 則 父 類 別 的 private 成 員 無 法 允 許 子 類 別 中 使 用,public 及 protected 成 員 允 許 在 子 類 別 中 使 用 ; 但 子 類 別 的 public private 及 protected 成 員 無 法 允 許 外 界 存 取 [ 結 論 ] 由 成 員 存 取 權 限 與 繼 承 存 取 權 限 的 組 合 方 式 可 知 道, 若 父 類 別 的 成 員 只 給 子 類 別 使 用 而 不 給 外 界 做 存 取, 此 時 子 類 別 的 成 員 就 必 頇 宣 告 為 protected 保 護 層 級 67

70 六 多 重 繼 承 以 下 為 族 譜 與 幾 何 圖 形 的 多 重 繼 承 圖 例, 關 於 族 譜 的 多 重 繼 承 可 參 考 下 方 的 baby.cpp 程 式, 以 瞭 解 C++ 中 如 何 完 成 多 重 繼 承 之 關 係 GetMon surname 爸 爸 GetMon surname 媽 媽 矩 形 四 邊 形 菱 形 寶 寶 正 方 形 Baby.cpp Cout<<Mother::GetMoney( )<<endl; cout<<father::father::surname<<endl; Long Child :: GetMoney ( ) return Father::GetMoney+Mother::GetMoney( ); 68

71 單 元 19: 虛 擬 函 數 與 多 型 (U19:Virtual Functions and Polymorphism) 一 虛 擬 函 數 (virtual functions) 與 多 型 (polymorphism) 火 車 汽 車 機 車 都 可 以 為 人 所 駕 駛 駕 駛 這 個 動 作 是 個 相 當 抽 象 的 名 詞, 火 車 汽 車 機 車 的 駕 駛 方 法 都 不 一 樣, 但 駕 駛 一 詞 涵 蓋 了 實 際 上 具 有 差 異 性 的 駕 駛 行 為 這 種 特 質 稱 為 多 形 性 (polymophism) 使 用 虛 擬 函 數 與 多 型, 我 們 可 以 設 計 實 作 出 更 具 彈 性 的 系 統 程 式 可 以 撰 寫 來 處 理 在 程 式 開 發 階 段 並 不 存 在 的 型 態 使 用 虛 擬 函 數 的 多 型 程 式 設 計 方 法, 可 以 避 免 使 用 switch 邏 輯 的 程 式 設 計 如 果 需 要 的 話, 衍 生 類 別 可 以 自 行 提 供 基 本 類 別 虛 擬 函 數 的 實 作 如 果 沒 有 提 供 自 己 的 實 作, 則 會 繼 承 基 本 類 別 的 實 作 內 容 如 果 使 用 物 件 的 名 稱 和 點 號 運 算 子 來 呼 叫 虛 擬 函 式, 這 種 形 式 的 參 照 將 會 在 編 譯 時 期 解 析 名 稱 ( 稱 為 靜 態 聯 繫 ), 然 後 程 式 會 呼 叫 這 類 別 所 定 義 的 虛 擬 函 數 二 抽 象 類 別 與 純 粹 虛 擬 函 數 在 許 多 情 況 下, 定 義 出 不 會 產 生 物 件 的 抽 象 類 別 是 很 有 用 的, 因 為 這 種 類 別 只 會 用 來 當 成 績 本 類 別, 所 以 我 們 通 常 將 它 們 稱 為 抽 象 基 本 類 別 而 會 產 生 實 體 物 件 的 類 別, 我 們 稱 之 為 具 象 類 別 如 果 將 類 別 中 一 個 或 多 個 虛 擬 函 式 宣 告 為 純 粹, 則 該 類 別 就 會 成 為 抽 象 類 別 純 類 別 函 式 的 宣 告 是 在 其 宣 告 中 加 入 純 粹 修 飾 子 (=0) 如 果 類 別 是 從 含 有 純 粹 虛 擬 函 式 的 類 別 繼 承 而 來, 並 且 該 衍 生 類 別 對 此 純 粹 虛 擬 函 式 並 未 提 供 任 何 定 義, 則 此 虛 擬 函 式 在 延 伸 類 別 中 仍 然 為 純 粹 虛 擬 函 式 因 此 這 個 衍 生 類 別 也 是 抽 象 類 別 C++ 提 供 多 型 的 功 能, 也 就 是 呼 叫 同 一 成 員 函 式, 可 以 獲 得 同 一 繼 承 階 層 下, 不 同 類 別 物 件 的 不 同 回 應 多 型 是 以 虛 擬 函 式 和 動 態 聯 繫 實 作 而 成 使 用 基 本 類 別 指 標 或 參 照 呼 叫 虛 擬 函 式 來 達 成 某 項 要 求 時,C++ 會 選 擇 適 當 的 類 別 來 呼 叫 其 重 載 的 函 式 透 過 虛 擬 函 式 與 多 型, 成 員 函 式 呼 叫 可 以 依 據 呼 叫 的 物 件 型 別 而 有 不 同 的 反 應 三 虛 擬 解 構 子 如 果 某 類 別 含 有 虛 擬 函 式, 則 必 頇 將 其 基 本 類 別 解 構 子 宣 告 為 虛 擬 解 構 子 這 會 使 所 有 衍 生 類 別 的 解 構 子 都 成 為 虛 擬 解 構 子, 即 使 這 些 解 構 子 與 基 本 類 別 解 構 子 的 名 稱 並 不 相 同 如 果 程 式 明 確 透 過 delete 運 算 子 來 清 除 基 本 類 別 指 標 指 向 的 衍 生 類 別 物 件, 責 成 市 會 呼 叫 適 當 類 別 的 解 構 子 在 衍 生 類 別 解 構 子 執 行 之 後, 會 沿 著 類 別 階 層 往 上 執 行 並 解 構 每 一 層 的 物 件, 直 到 跟 類 別 的 解 構 子 為 止 [ 範 例 ] 1. 假 設 一 般 來 說 員 工 和 經 理 的 底 薪 一 定 不 相 同 2. 定 義 一 個 Empolyee 員 工 類 別 3. 定 義 一 個 設 定 薪 水 SetSalary() 方 法, 該 方 法 可 設 定 5. _salary 屬 於 介 於 20,000~40,000 之 間 5. 讓 Manger 經 理 類 別 的 SetSalary() 方 法 覆 寫 Empolyee 父 類 別 的 SetSalary() 方 法 6. 重 新 定 義 Manger 經 理 類 別 的 SetSalary() 方 法, 使 _salary 屬 性 介 於 30,000~60,000 69

72 程 式 碼 FileName:Polymorphism-1.sln 01 #include <cstdlib> 02 #include <iostream> 03 #include <string> 04 using namespace std; class Empolyee protected: 09 //_salary 宣 告 為 保 護 層 級, 此 欄 位 可 以 在 子 類 別 中 使 用 10 int _salary; 11 public: 12 int GetSalary() return _salary; void SetSalary(int value) // 設 定 薪 水 介 於 20000~ if ((value >= 20000) && (value <= 40000)) _salary = value; else _salary = 20000; ; class Manger : public Empolyee public: 32 int Bonus; 33 int GetSalary () return _salary;// 使 用 父 類 別 的 m_salary void SetSalary(int value) // 設 定 薪 水 介 於 30000~ if ((value >= 30000) && (value <= 60000)) _salary = value; else _salary = 30000; 70

73 void ShowTotal() cout << " 實 領 薪 水 :" << ( Bonus + GetSalary()) << endl; ; 53 71

74 單 元 20: 串 流 輸 入 / 串 流 輸 出 (U20:Stream Input/Output) 大 部 分 的 科 學 計 算 或 工 程 應 用 程 式, 都 需 要 一 些 外 部 的 資 料 檔, 像 是 原 始 實 驗 數 據 測 詴 資 料 語 音 或 影 像 訊 號, 這 些 資 料 都 是 以 獨 立 檔 案 方 式 存 在 為 了 考 量 程 式 的 泛 用 性, 因 此 若 能 在 更 換 不 同 的 資 料 檔 時 都 能 不 需 重 新 編 譯 程 式, 這 便 是 本 單 元 所 欲 介 紹 之 檔 案 輸 入 / 輸 出 的 功 能 一 串 流 (stream) C++ 的 I/O 是 以 串 流 (Stream) 為 基 礎, 它 們 是 連 續 的 位 元 組 序 列 在 輸 入 操 作 時, 它 會 由 由 輸 入 裝 置 ( 鍵 盤, 硬 碟 ) 流 到 主 記 憶 體 在 輸 出 操 作 時, 會 由 主 記 憶 體 流 到 裝 置 ( 螢 幕, 印 表 機 等 ) I/O 運 作 通 常 很 花 時 間, 例 如 : 等 待 硬 碟 或 鍵 盤 輸 入 而 低 階 I/O 也 就 是 未 格 式 化 的 I/O, 只 是 將 一 些 位 元 組 在 裝 置 與 記 憶 體 間 傳 送, 若 要 提 供 高 速 傳 輸 則 並 不 方 便 使 用 因 此 一 個 位 元 組 一 個 位 元 組 的 連 續 高 速 傳 送, 以 進 行 大 量 的 資 料 傳 輸 則 有 其 重 要 性 而 高 階 I/O 則 具 有 格 式 化 的 特 性, 並 以 位 元 組 群 ( 整 數, 字 串 等 ) 方 式 傳 輸, 較 適 合 使 用 典 型 串 流 可 讓 使 用 者 輸 入 / 輸 出 chars ( 一 個 位 元 組 ), 因 為 char 會 佔 用 一 個 位 元 組, 所 以 它 只 能 代 表 有 限 的 字 元 集 合 而 標 準 串 流 函 式 庫, 因 應 大 部 份 語 言 需 要 特 殊 文 字, 可 讓 開 發 者 建 立 以 Unicode 字 元 執 行 I/O 操 作 以 支 援 多 種 文 字 針 對 此 目 的,C++ 包 含 額 外 的 字 元 集, 稱 為 wchar_t, 因 此 輸 入 / 輸 出 皆 可 使 用 unicode iostream 函 式 庫 提 供 了 多 個 標 頭 檔, 具 有 數 百 種 I/O 存 取 能 力 大 部 分 C++ 都 具 有 <iostream.h> 標 頭 檔, 它 會 宣 告 所 有 串 流 I/O 操 作 需 要 的 基 本 服 務 <iostream.h> 標 頭 定 義 了 標 準 輸 入 (cin) 標 準 輸 出 (cout) 不 經 緩 衝 的 錯 誤 訊 息 輸 出 (cerr) 經 緩 衝 的 錯 誤 訊 息 輸 出 (clog) 等 而 <iomanip.h> 使 用 串 流 操 作 子 (stream manipulators) 設 定 輸 入 輸 出 格 式 <fstream.h> 提 供 檔 案 處 理 相 關 功 能 iostream 函 式 庫 提 供 basic_istream ( 串 流 輸 入 ) basic_ostream ( 串 流 輸 出 ) basic_iostream ( 串 流 輸 入 與 輸 出 ) 等 三 種 I/O 類 別 樣 版, 並 可 供 輸 入 輸 出 字 元 二 標 準 串 流 運 算 子 cin 是 一 種 istream 物 件, 它 們 會 連 接 到 標 準 輸 入 ( 通 常 是 鍵 盤 ) cin >> grade;, 會 從 cin 傳 一 個 值 到 記 憶 體 此 例 中, 此 時 編 譯 譯 器 會 先 確 認 grade 資 料 型 態, 再 呼 叫 適 當 的 多 載 運 算 子, 而 不 需 提 供 額 外 的 型 態 資 訊 cout 是 一 種 ostream 物 件, 它 們 會 連 接 到 標 準 輸 出 ( 通 常 顯 示 在 螢 幕 上 ) cout << grade;, 會 連 結 到 標 準 輸 出 裝 置 此 例 中, 編 譯 器 先 確 認 grade 資 料 型 態, 再 呼 叫 適 當 的 多 載 運 算 子, 而 不 需 提 供 額 外 的 型 態 資 訊 cerr, clog 也 都 是 一 種 ostream 物 件, 它 們 連 接 到 標 準 錯 誤 裝 置 時,cerr 會 立 即 輸 出 而 clog 則 會 先 存 入 輸 出 緩 衝 區, 等 到 緩 衝 區 滿 之 後 則 輸 出, 此 方 法 有 效 能 上 的 好 處 三 輸 出 串 流 Ostream 提 供 格 式 化 與 非 格 式 化 的 輸 出 功 能, 它 的 輸 出 功 能 包 括 使 用 標 準 資 料 型 態 (<<) 輸 出 標 準 資 料 型 別 使 用 put 函 式 輸 出 字 元 使 用 write 成 員 函 數 進 行 非 格 式 化 輸 出 以 十 進 位 (decimal)/ 八 進 位 (octal)/ 十 六 進 位 (hexadecimal) 輸 出 整 數 輸 出 不 同 精 確 度 的 浮 點 數 以 固 定 小 數 位 數 格 式 輸 出 浮 點 數 以 科 學 記 號 法 和 定 點 格 式 輸 出 浮 點 數 在 指 定 寬 度 中 對 齊 方 式 72

75 輸 出 資 料 填 補 空 格 輸 出 等 ( 一 )put 函 式 輸 出 字 元 :put 函 式 用 以 輸 出 字 元, 指 令 寫 法 如 下 cout.put( 'A' ) 可 串 接 字 元 : 其 中 的 點 運 算 子 (.) 由 左 至 右 執 行 cout.put( 'A' ).put( '\n' ); 可 使 用 ASCII 數 值 cout.put( 65 ); <- 印 出 'A' ( 二 ) 格 式 化 與 非 格 式 化 輸 入 可 使 用 istream 函 式 庫, 其 中 的 >> 運 算 子 通 常 會 忽 略 空 白 字 元 (blanks, tabs, newlines), 沒 東 西 讀 (EOF) 時 會 傳 回 0, 否 則 傳 回 物 件 的 參 考 (reference) 例 如 :cin>>grade; ( 三 )get 函 式 get 函 式 的 寫 法 為 cin.get(), 它 是 由 輸 入 串 流 傳 回 一 個 字 元 ( 含 空 白 字 元 ) 至 程 式, 假 如 已 經 讀 到 檔 案 結 尾 則 傳 回 EOF 檔 案 結 尾 EOF(End-of-file) 則 表 示 輸 入 內 容 已 被 讀 完 cin.eof() 會 在 已 至 檔 案 結 尾 時 傳 回 1, 否 則 傳 回 0 四 輸 入 串 流 get(charref) 會 利 用 傳 參 考 方 式 來 取 得 一 個 字 元, 並 放 入 charref 假 如 EOF 則 傳 回 -1 get(chararray, size, delimiter) 會 以 一 次 讀 取 size-1 個 字 元 或 直 到 遇 到 邊 界 符 號 (delimiter) 方 式 進 行 邊 界 符 號 在 陣 列 後 面 是 以 \0 結 尾, 預 設 邊 界 符 號 為 '\n', 而 邊 界 符 號 仍 會 留 在 輸 入 串 流 中 若 要 移 除 邊 界 符 號 可 使 用 可 用 cin.get() 或 cin.ignore() getline(array, size, delimiter) 跟 get 一 樣, 一 次 讀 取 size-1 個 字 元, 或 直 到 遇 到 邊 界 符 號 (delimiter), 陣 列 後 面 以 \0 結 尾, 預 設 邊 界 符 號 為 '\n', 但 會 將 邊 界 符 號 從 輸 入 串 流 中 去 除 ignore(num) 可 用 以 忽 略 輸 入 串 流 中 的 字 元,num 預 設 值 是 1, 直 到 遇 到 邊 界 符 號 (delimiter) 預 設 邊 界 符 號 是 EOF putback() 可 將 字 元 放 入 輸 入 串 流 中 peek() 可 傳 回 輸 入 串 流 中 的 字 元, 但 不 移 除 該 字 元 五 串 流 操 作 子 串 流 操 作 子 (manipulator) 的 功 能 : ( 一 ) 可 設 定 串 流 格 式 : 例 如 :#include <iomanip> 欄 位 長 度 精 確 度 格 式 旗 號 (Flags) 填 滿 字 元 清 空 串 流 在 輸 出 串 流 插 入 換 行 符 號 在 輸 入 串 流 跳 過 空 白 字 元 ( 二 ) 可 設 定 整 數 數 字 系 統 : 串 流 操 作 子 可 改 變 整 數 數 字 系 統, 包 括 dec 的 10 進 位 ( 預 設 值 ) hex 的 16 進 位 oct 的 8 進 位, 其 用 法 為 : cout << hex << myinteger setbase(newbase) 可 處 理 8, 10, 或 16 近 位, 用 法 為 : cout << setbase(8) << myinteger ( 三 ) 具 備 浮 點 數 表 示 法 : 包 括 了 fixed 及 scientific 兩 類 ( 四 ) 設 定 浮 點 數 精 確 度 : 要 在 小 數 點 右 邊 顯 示 幾 位 數 字, 可 使 用 setprecision 操 作 子, 例 如 : cout << setprecision(5), 或 使 用 precision 成 員 函 式 cout.precision(newprecision), 執 行 後 會 傳 回 改 變 前 的 精 確 度 設 定, 沒 給 參 數 的 話 則 會 傳 回 目 前 的 精 確 度 ( 五 ) 設 定 欄 位 寬 度 : 使 用 width 成 員 函 式 ( 基 礎 類 別 ios_base), 例 如 :cin.width(5) 它 可 設 定 欄 位 寬 度 及 傳 回 原 來 寬 度 73

76 ( 六 ) 填 滿 空 白 字 元 ( 七 ) 使 用 者 可 以 自 訂 串 流 操 作 子 六 串 流 格 式 設 定 許 多 串 流 操 作 子 可 用 來 設 定 輸 出 格 式, 這 些 串 流 操 作 子 全 部 繼 承 自 ios_base 其 中 的 showpoint 可 強 制 印 出 小 數 點 及 數 字 後 面 的 0, 例 如 : 一 個 十 進 位 數 字 79.0, 沒 有 使 用 showpoint 會 印 出 79, 使 用 showpoint 可 能 印 出 印 多 少 0 視 準 確 度 而 定 Noshowpoint 則 會 取 消 showpoint 設 定 串 流 格 式 設 定 的 對 齊 方 式 與 width 寬 度 有 關, 其 中 的 left 會 使 字 元 靠 左 對 齊,Right 會 使 字 元 靠 右 對 齊 Internal 會 使 正 負 號 符 號 靠 左, 數 字 靠 右 此 外 串 流 格 式 設 定 還 包 含 顯 示 數 字 系 統 填 充 (Padding) 填 充 (Padding) 可 將 所 設 定 寬 度 中 空 白 處 以 填 充 字 元 填 滿, 要 設 定 填 充 字 元 可 使 用 fill 成 員 函 式, 例 如 :cout.fill('*') 也 可 使 用 setfill 串 流 操 作 子, 例 如 :setfill( '^' ) 另 外,scientific 串 流 操 作 子 可 強 制 以 科 學 符 號 表 示 fixed 串 流 操 作 子 則 可 使 用 定 點 格 式, 如 果 沒 有 指 定, 數 字 的 內 容 決 定 使 用 哪 種 方 式 而 大 小 寫 控 制 包 含 uppercase 串 流 操 作 子, 它 使 用 大 寫 方 式 表 示 科 學 記 號 表 示 法, 例 如 :1E10 若 要 使 用 大 寫 方 式 表 示 16 進 位 表 示 法 則 為 0XABCD, 預 設 值 是 小 寫 (lowercase),nouppercase 則 是 清 除 設 定 七 串 流 錯 誤 狀 態 要 測 詴 位 元 串 流 狀 態, 可 使 用 eofbit 及 failbit Eofbit 會 在 EOF 成 立 時 被 設 定, 假 如 eofbit 被 設 定, 傳 回 true, 所 以 cin.eof() 會 傳 回 eofbit 內 容 而 failbit 會 在 串 流 發 生 錯 誤 時 被 設 定, 如 果 資 料 沒 丟 掉, 錯 誤 可 回 復, 所 以 cin.fail() 會 傳 回 failbit 內 容 Badbit 會 在 資 料 遺 失 時 被 設 定, 通 常 無 法 回 復 Goodbit 會 在 badbit, failbit 與 eofbit 都 為 0 時 被 設 定 成 員 函 式 rdstate() 會 傳 回 串 流 錯 誤 狀 態, 可 供 使 用 goodbit, badbit 等 測 詴, 比 使 用 good(), bad() 好 clear() 可 清 除 錯 誤 狀 態, 需 設 定 串 流 至 正 常 狀 態,I/O 才 可 以 繼 續, 它 也 可 用 來 設 定 錯 誤 狀 態 輸 入 格 式 錯 誤 時,failbit 被 設 定, 此 時 使 用 cin.clear() 可 清 除 錯 誤 狀 態, 如 果 沒 有 清 除 輸 入 串 流 內 容, 因 為 格 式 錯 誤, 沒 有 被 讀 出 來, 所 以 還 留 在 串 流 內, 如 果 要 讓 程 式 繼 續 執 行, 就 需 清 除 輸 入 串 流 內 容, 此 時 可 使 用 cin.seekg(0,ios::end); 74

77 單 元 21: 樣 版 (U21:Templates) 樣 版 (Templates) 可 區 分 為 函 式 樣 版 (Function Templates) 及 類 別 樣 版 (Class Templates), 函 式 樣 版 可 用 來 建 構 功 能 相 同 的 函 式, 類 別 樣 版 則 可 用 來 建 構 功 能 相 同 的 類 別 一 函 式 樣 版 (template) 多 載 函 式 具 有 相 似 運 算 - 不 同 資 料 型 態, 可 針 對 一 個 signature 撰 寫 一 個 函 式 而 函 式 樣 版 則 具 有 相 同 運 算 - 不 同 資 料 型 態, 它 只 需 撰 寫 一 個 函 式 樣 版, 編 譯 器 會 產 生 多 個 不 同 的 函 式, 而 且 會 進 行 型 態 檢 查 函 式 樣 版 是 在 < > 括 號 內 列 出 型 態 參 數, 型 態 參 數 前 使 用 關 鍵 字 class 或 typename, 而 class 和 typename 可 互 換 例 如 : template< class T > template< typename ElementType > template< class BorderType, class FillType > 此 外, 函 式 樣 版 也 可 用 來 表 示 多 種 型 態 的 參 數 傳 回 資 料, 或 函 式 內 變 數 當 設 計 一 個 求 絕 對 值 的 GetAbs() 函 式, 它 能 按 照 函 式 參 數 內 的 資 料 型 別, 傳 回 該 資 料 型 別 的 絕 對 值, 此 時 便 要 使 用 多 載 函 式 譬 如 下 面 敘 述 是 定 義 一 個 多 載 的 GetAbs() 函 式 可 用 來 傳 回 整 數 型 別 長 整 數 型 別 單 精 確 度 型 別 倍 精 確 度 型 別 資 料 的 絕 對 值 : 75