113 年 國立成功大學資訊管理研究所甲組《計算機概論》

本題考驗對軟體框架 (Framework) 定義的理解。軟體框架是一個預先定義好的結構，它提供了一套通用的功能和控制流程，開發者可以在此框架的基礎上編寫自己的應用程式，填入特定的邏輯。框架的設計宗旨是「反轉控制」(Inversion of Control, IoC)，也就是說，框架會調用開發者的程式碼，而不是開發者的程式碼去調用框架的特定功能。題目敘述「you can call from your code which dictates the flow of control」與框架的定義是相反的，框架是 dictating the flow of control，而我們的程式碼是填入框架中。

本題在探討統一語言模型 (Unified Modeling Language, UML) 中，用於描述系統靜態視圖的模型。UML 提供了多種圖來表示系統的不同方面。靜態視圖主要關注系統的結構，包括類別、物件、介面及其之間的關係。

核心觀念：UML 圖示的分類與用途。
UML 圖可以大致分為兩大類：結構圖 (Structure Diagrams) 和行為圖 (Behavior Diagrams)。

• 結構圖 (Structure Diagrams)：描述系統的靜態結構，包括類別、物件、元件、節點等。它們關注系統的組成部分以及這些部分之間的關係。
  • 類別圖 (Class Diagram)：描述系統的類別、屬性、操作以及類別之間的關係（如繼承、關聯、聚合、組合）。
  • 物件圖 (Object Diagram)：描述系統在特定時間點的物件實例及其關係。
  • 元件圖 (Component Diagram)：描述系統的物理結構，包括元件及其依賴關係。
  • 部署圖 (Deployment Diagram)：描述系統的硬體和軟體架構，包括節點、裝置及其之間的關係。
  • 組合結構圖 (Composite Structure Diagram)：描述一個類別的內部結構。
  • 封裝圖 (Package Diagram)：描述包之間的依賴關係。
• 行為圖 (Behavior Diagrams)：描述系統的動態行為，包括物件之間的互動、系統狀態的變化等。

本題考驗物件導向程式設計 (Object-Oriented Programming, OOP) 的四大基本特性之一：多型 (Polymorphism)。

核心觀念：物件導向程式設計的四大基本特性。

1. 封裝 (Encapsulation)：將資料（屬性）和操作（方法）綁定在一個單元（類別）中，並隱藏內部實現細節，只暴露必要的介面。這有助於提高模組化和安全性。
2. 繼承 (Inheritance)：允許一個類別（子類別）繼承另一個類別（父類別）的屬性和方法，從而實現程式碼重用和建立類別層次結構。
3. 多型 (Polymorphism)：字面意思是「多種形態」。在物件導向程式設計中，多型指的是允許不同的物件對相同的訊息（方法呼叫）做出不同的響應。這通常通過方法重載 (Overloading) 或方法覆寫 (Overriding) 來實現。題目中描述的「call the same method on different objects, which can be interpreted differently by different objects」正是多型的核心概念。

本題考驗對物件導向系統中「耦合」(Coupling) 類型的理解。耦合是指兩個模組之間相互依賴的程度。在物件導向設計中，我們通常希望降低耦合度，以提高系統的靈活性、可維護性和可重用性。

核心觀念：物件導向系統中的耦合類型。
在物件導向設計中，耦合的概念通常與類別之間的依賴關係有關。雖然沒有一個絕對標準的分類，但常見的耦合類型包括：

1. 內容耦合 (Content Coupling)：一個模組修改另一個模組的內部數據或邏輯。這是最差的耦合。
2. 公共耦合 (Common Coupling)：多個模組共享一個全局數據結構。
3. 控制耦合 (Control Coupling)：一個模組傳遞一個旗標或命令給另一個模組，影響其邏輯。
4. 標記耦合 (Stamp Coupling)：模組之間傳遞的數據結構，但接收方只使用其中一部分。
5. 資料耦合 (Data Coupling)：模組之間通過傳遞參數進行互動，且參數是簡單的數據類型。
6. 印記耦合 (Data Structure Coupling)：模組之間傳遞複合數據結構（如結構體、物件），但接收方使用其中的所有成員。

本題考驗對軟體開發方法論與統一建模語言 (UML) 之間關係的理解。UML 是一種建模語言，而各種開發方法論則提供了如何使用 UML 來進行分析與設計的指導。

核心觀念：軟體開發方法論與 UML。

• UML (Unified Modeling Language)：是一種標準化的通用建模語言，用於指定、可視化、構建和文檔化軟件系統的各種工件。它提供了一套圖形符號和規則來描述軟件系統的結構和行為。
• Prototyping (原型法)：一種開發過程，通過快速構建系統的部分或全部原型來收集用戶需求和驗證設計。
• Waterfall Model (瀑布模型)：一種線性的、順序的開發模型，每個階段（需求、設計、實現、測試、維護）必須完成後才能進入下一階段。
• Scrum (敏捷開發框架)：一種迭代和增量的敏捷開發框架，強調團隊協作、快速響應變化和持續交付。
• Unified Process (統一過程，UP)：一種迭代和增量的軟體開發過程框架，它強調了物件導向的分析與設計，並明確建議使用 UML 來進行建模。UP 提供了關於在開發週期的不同階段（如概念、精煉、構建、遷移）如何應用 UML 圖的指導。

核心觀念
此題測驗「繼承」與「多型」的概念。

• 超類別（super class）：在類別階層中較上層的類別，定義共用介面與行為。
• 子類別（subclass）：繼承自超類別，可能擴充或覆寫（override）超類別的方法。
• 向上呼叫（upward call）：超類別直接呼叫子類別自行新增且未在超類別宣告的方法。
  在物件導向語言（如 Java、C++、C#）中，多型允許超類別以其宣告的介面呼叫方法，實際執行時會根據物件之實例類別（子類別）決定執行哪個實作。但前提是該方法必須在超類別已聲明（抽象或具體），否則編譯或執行時無法找到呼叫目標。

解題方法

1. 判斷題目敘述的「不可能」指的是編譯階段或執行階段的不可行性。
2. 檢視語言規範：
   • 若子類別新增的方法未在超類別介面中宣告，超類別的程式碼無法直接呼叫（編譯錯誤）。
   • 若方法已在超類別宣告（抽象或具體），則超類別可透過多型呼叫，執行時會呼叫子類別的覆寫實作。
3. 因此「超類別永遠無法呼叫子類別的方法」的斷言過於絕對，僅在未宣告的情況下才成立，整體而言是錯誤的。

選項分析

• a. True
  • 錯誤。在多型機制下，若子類別覆寫了超類別已宣告的抽象或具體方法，超類別透過該方法的介面即可呼叫，執行時會自動轉派到子類別

本題考驗對軟體組件 (Software Component) 定義的理解。軟體組件是軟體工程中的一個基本概念，用於模組化和可重用性。

核心觀念：軟體組件 (Software Component) 的定義。
一個軟體組件通常被定義為：

1. 自包含 (Self-contained)：它具有獨立的功能，不需要依賴於系統中的其他特定組件來執行其基本任務。
2. 封裝 (Encapsulated)：它隱藏了內部的實現細節，只暴露清晰定義的介面 (interface)。這意味著其他組件只能通過其介面與之互動。

核心觀念
RSA（Rivest–Shamir–Adleman）是一種基於大數分解難題的非對稱加密演算法。其關鍵特性包括：

• 公私鑰對：每位使用者擁有一組公鑰 $(e,n)$ 與私鑰 $(d,n)$，其中 $n=pq$ 為兩個大質數的乘積。
• 加解密關係：對訊息 $m$（$0\le m<n$），加密為 $c \equiv m^{e}\pmod n$，解密則 $m \equiv c^{d}\pmod n$。
• 數位簽章：利用私鑰對訊息雜湊值 $h(m)$ 產生簽章 $s \equiv h(m)^{d}\pmod n$，驗證時使用對方的公鑰：$h(m) \stackrel{?}{=} s^{e}\pmod n$。
• 安全性假設：若能在多項式時間內分解 $n$，則 RSA 不安全；此外，RSA 在純文本加密上較慢，且需防止「選擇密文攻擊（chosen‑ciphertext attack, CCA）」等側信道。

解題方法
本題屬於概念判斷型多選題，只需比對每個選項與 RSA 的正確特性。檢視四個敘述，判斷是否符合 RSA 的定義與已知事實即可。

選項分析

• a. Encryption and decryption must use the same key
  RSA 為非對稱加密，公鑰與私鑰不同。加密使用公鑰 $e$，解密使用私鑰 $d$（或相反於簽章情境）。此敘述與 RSA 定義相左。錯誤。

• b. Encryption using the public key of a user can be regarded as a digital signature

核心觀念

• DES（Data Encryption Standard）：一種 64 位元分組密碼（block cipher），每次加密 64‑bit 資料塊。
• 金鑰長度：實際有效金鑰為 56 位元（64 位元中每第 8 位為奇偶校驗位），因此金鑰長度不是 512 位元。
• 雙重 DES（Double‑DES）：使用兩個不同金鑰依序加密 $E_{K_2}(E_{K_1}(P))$，理論上金鑰空間應為 $2^{112}$，但因 Meet‑in‑the‑Middle 攻擊，有效安全度僅約 $2^{57}$，與單一 DES 相差不大。
• 資料塊小於 64 位元：可透過 填充（padding）（如 PKCS#5/7）將訊息擴充至 64 位元再加密，故「無法加密」的說法錯誤。
• 串流密碼（stream cipher）：若將區塊密碼以 OFB (Output Feedback)、CFB (Cipher Feedback) 或 CTR (Counter) 等模式運作，產生每位元的鍵流，實質上即為串流密碼的實作。

解題方法

1. 認定題目型態：本題為單選題，需辨識每個敘述的真偽。
2. 列出 DES 的關鍵規格：
   • 資料塊長度 $=64$ bit
   • 金鑰長度（含奇偶位）$=64$ bit，實際安全金鑰 $=56$ bit
   • 加密輪次 $=16$（Feistel 結構）
3. 針對每個選項檢驗：根據上列規格與已知攻擊/模式特性，直接判斷正確與否。
4. 特別注意：題目問「Which is true regarding DES?」，因此只要有一項敘述在常識或標準教材中被認可即為正確答案。

選項分析

本題考驗對安全雜湊函數 (Secure Hash Function) 特性的理解，包括其在數位貨幣、密碼學應用中的作用，以及其固有的數學性質和潛在弱點。

核心觀念：安全雜湊函數 (Secure Hash Function) 的特性。
安全雜湊函數具有以下主要特性：

1. 單向性 (One-wayness)：給定雜湊值 $h$，很難（計算上不可行）找到原始訊息 $m$ 使得 $H(m) = h$。
2. 抗碰撞性 (Collision Resistance)：
   • 弱抗碰撞性 (Weak Collision Resistance)：給定一個訊息 $m_1$，很難找到另一個不同的訊息 $m_2$ 使得 $H(m_1) = H(m_2)$。
   • 強抗碰撞性 (Strong Collision Resistance)：很難找到任意兩個不同的訊息 $m_1$ 和 $m_2$ 使得 $H(m_1) = H(m_2)$。
3. 雪崩效應 (Avalanche Effect)：輸入訊息的微小改變（如改變一個位元）會導致輸出雜湊值產生巨大的、不可預測的變化（約一半的輸出位元會改變）。
4. 確定性 (Deterministic)：相同的輸入總是產生相同的輸出。

應用：

• 數位簽章：雜湊函數用於生成訊息的雜湊值，然後對雜湊值進行加密，以實現數位簽章。
• 訊息完整性檢查：通過比對雜湊值來驗證訊息在傳輸過程中是否被篡改。
• 密碼儲存：將密碼雜湊後儲存，以防止明文密碼洩露。
• 數位貨幣 (如比特幣)：雜湊函數在區塊鏈技術中扮演核心角色，用於區塊的鏈接、工作量證明 (Proof-of-Work) 等。

選項分析：
a. Secure hash functions play a crucial role in the context of digital currency.
這是正確的。例如，比特幣使用 SHA-256 作為其工作量證明機制的一部分，並用於生成區塊鏈的雜湊值。

b. It is possible that two different data blocks are mapped to the same hash code by a secure hash function.
這是正確的。

本題考驗對軟體設計模式中「介面適配器」(Adapter) 設計模式的理解，包括其定義、目的、結構和應用場景。

核心觀念：介面適配器 (Adapter) 設計模式。
介面適配器模式是一種結構型設計模式，它允許不兼容的介面之間協同工作。這個模式將一個類別的介面轉換成客戶端期望的另一個介面。介面適配器模式使得原本由於介面不兼容而無法一起工作的類別可以一起工作。

目的：

• 讓原本由於介面不兼容而無法一起工作的類別能夠協同工作。
• 將一個類別的介面轉換成客戶端所期望的另一個介面。
• 在不修改現有類別的原始碼的情況下，使其與其他類別兼容。

結構：
介面適配器模式通常包含以下角色：

1. 目標介面 (Target Interface)：客戶端所期望的介面。
2. 客戶端 (Client)：使用目標介面的物件。
3. 適配器 (Adapter)：
   • 實現目標介面 (Target Interface)。
   • 維護一個對被適配類別 (Adaptee) 的引用。
   • 在調用目標介面的方法時，將請求轉換成對被適配類別相應方法的調用。
4. 被適配類別 (Adaptee)：一個已經存在的、擁有不兼容介面的類別。

兩種常見的實現方式：

• 類別適配器 (Class Adapter)：通過多重繼承實現。適配器類別繼承目標介面和被適配類別。
  • 優點：可以覆寫被適配類別的方法。
  • 缺點：只能適配單個被適配類別（由於多重繼承的限制，尤其是在 Java 等不支援多重繼承的語言中）。
• 物件適配器 (Object Adapter)：通過組合實現。適配器類別實現目標介面，並包含一個被適配類別的實例。
  • 優點：更加靈活，可以適配一個類別及其所有子類別，並且符合組合優於繼承的原則。
  • 缺點：不能覆寫被適配類別的方法（除非被適配類別的方法是虛擬的，且適配器繼承了被適配類別）。

範例：
假設我們有一個舊的、已經存在的 LegacyRectangle 類別，它有一個 draw() 方法，但它的參數是 width 和 height。現在我們有一個新的系統，期望使用一個 Shape 介面，其中包含一個 render() 方法，該方法接收一個 Point 物件作為參數來定義矩形的左上角和右下角。

• Target Interface: Shape (with render(Point topLeft, Point bottomRight))
• Client: 任何使用 Shape 介面的類別。
• Adaptee: LegacyRectangle (with draw(int width, int height))

我們可以創建一個 RectangleAdapter 類別：

1. 物件適配器 (Object Adapter) 實現：

本題考驗對軟體設計原則中「內聚」(Cohesion) 的理解，包括其定義、重要性以及在軟體設計中的價值。

核心觀念：內聚 (Cohesion)。
內聚 (Cohesion) 是衡量一個模組（如函數、類別、檔案）內部元素之間相關性或緊密程度的指標。高內聚的模組，其內部元素（如方法、屬性）都圍繞著一個單一、明確的職責或功能而組織。換句話說，一個高內聚的模組，它所做的事情是高度相關的。

內聚的類型（從低到高）：

1. 偶然內聚 (Coincidental Cohesion)：模組中的元素只是偶然地放在一起，沒有明顯的共同目的。
2. 邏輯內聚 (Logical Cohesion)：模組中的元素執行相似類型的操作，但這些操作是通過一個參數來選擇執行的。例如，一個處理所有輸入/輸出操作的函數。
3. 時間內聚 (Temporal Cohesion)：模組中的元素在同一時間點被執行。例如，一個在程式開始時執行的初始化函數。
4. 順序內聚 (Sequential Cohesion)：模組中的元素執行一個序列的步驟，其中一個元素的輸出是下一個元素的輸入。
5. 通訊內聚 (Communicational Cohesion)：模組中的元素操作相同數據結構的數據。
6. 函數內聚 (Functional Cohesion)：模組中的所有元素都參與執行單一、明確定義的功能。這是較好的內聚類型。

本題考驗對 C++ 中參數傳遞方式（傳值與傳引用）的理解，以及 const 關鍵字在確保安全性方面的作用。

核心觀念：C++ 的傳值 (Call-by-Value) 與傳引用 (Call-by-Reference)。

• 傳值 (Call-by-Value)：當函數被調用時，參數的副本被創建並傳遞給函數。函數內部對參數的修改不會影響到原始變數。對於大型物件，傳遞副本可能效率較低，因為需要複製整個物件。
• 傳引用 (Call-by-Reference)：函數接收的是原始變數的引用（或別名），而不是副本。函數內部對參數的修改會直接影響到原始變數。這對於大型物件可以提高效率，因為不需要複製。

題目問的是「call-by-reference can achieve the security of call-by-value」。
「Security of call-by-value」指的是傳值方式可以保護原始變數不被函數修改。
因此，題目實際上是在問：在什麼情況下，使用傳引用（或類似機制）可以達到傳值那樣的安全性，即保證原始變數不被修改，同時又能享受傳引用（或指針）在效率上的優勢（尤其適用於大型物件）。

選項分析：
a. The value being passed is small.
如果傳遞的值很小（例如基本類型如 int, float），傳值和傳引用在效率上的差異不大，而且傳值本身就提供了安全性。所以這不是使用傳引用來獲得安全性的原因。

b. The const qualifier is used.
這是正確的。在 C++ 中，當我們使用傳引用（例如 void func(Type& arg)）或傳指針（例如 void func(Type* arg)）時，如果

核心觀念

本題考查遞迴（recursion）執行時的記憶體使用方式，關鍵在於：

• 函式每被呼叫一次，就會建立一筆啟動記錄（activation record，也稱 stack frame）。
• 啟動記錄通常包含參數、區域變數、返回位址，以及保存函式執行狀態所需的資訊。
• 遞迴函式在尚未完成目前呼叫前，又呼叫自己，因此先前的函式呼叫必須保持「開啟」狀態。
• 這些尚未完成的啟動記錄會依序堆疊在呼叫堆疊（call stack）中，直到遞迴返回才逐一移除。

例如：

f(3)
 └─ f(2)
     └─ f(1)
         └─ f(0)

在抵達最深層前，f(3)、f(2)、f(1) 都尚未結束，因此其啟動記錄同時存在於 call stack 中。

若遞迴深度為 $n$，且每層啟動記錄的大小近似固定，則額外空間複雜度通常為：

解題方法

判斷本題的切入點是區分：

1. 函式的程式碼本體是否會重複建立。
2. 函式每次呼叫所產生的執行狀態是否會重複保存。

遞迴時，函式程式碼通常只儲存一份，所有呼叫共用同一份程式碼；但每一次呼叫都必須保存自己的參數、區域變數與返回位置。因此，隨著遞迴深度增加，call stack 中會同時存在多筆啟動記錄，造成記憶體使用量增加。

所以正確原因是：

前一次函式呼叫尚未結束，當函式再次呼叫自己時，前一次呼叫的啟動記錄仍占用 call stack 空間。

選項分析

(a) It requires large data values.

錯誤。

遞迴本身不必然需要大型資料。遞迴函式可以只處理一個整數、指標或小型資料結構；即使資料量很小，只要遞迴深度很深，仍可能因大量啟動記錄堆疊而消耗許多記憶體。

記憶體消耗的主要因素是遞迴深度與每層啟動記錄大小，不是資料值本身是否很大。

(b) Many copies of the function code are created.

錯誤。

本題考驗對 C++ 中指標 (pointer) 的比較和指標算術 (pointer arithmetic) 的語義和限制的理解。

核心觀念：C++ 指標的比較與算術。
在 C++ 中，指標算術（如 ptr + n 或 ptr - n）和指標比較（如 ptr1 < ptr2）只有在指標指向同一個陣列（或同一陣列的某個元素之後）的元素時才有明確定義且有意義。

• 指標算術 (Pointer Arithmetic)：當一個指標指向一個陣列元素時，對該指標進行加或減一個整數 n 的操作，實際上是將指標移動到陣列中第 n 個元素之後或之前的元素。移動的位元組數是 n 乘以該元素類型的大小。例如，int* p; p + 1; 會將 p 向後移動 sizeof(int) 位元組。
• 指標比較 (Pointer Comparison)：兩個指標之間的比較（<, >, <=, >=）只有在它們指向同一個陣列的元素時才有明確的順序關係。如果它們指向不同的陣列，或者其中一個是指向陣列的指標而另一個是空指針，則比較結果是未定義的。

選項分析：
a. They point to elements of the same array.
這是正確的。指標比較和指標算術在 C++ 中只有在指標指向同一個陣列的元素時，才有明確的定義和有意義的結果。

核心觀念

本題考查 C++ 的「函式指標」與「函式呼叫」語法。

若 min 是一個指向函式的指標，則：

(*min)(number1, number2, number3);

可拆解為：

1. *min：取得 min 所指向的函式。
2. (number1, number2, number3)：以三個引數呼叫該函式。

因此，整體意義是「呼叫由 min 指標所指向的函式」。

函式指標的宣告範例如下：

int (*min)(int, int, int);

表示 min 是一個函式指標，指向「接收三個 int 引數並回傳 int」的函式。

解題方法

先觀察語法：

(*min)(number1, number2, number3);

括號中的 *min 是對函式指標進行解參照，取得它所指向的函式；後方的括號則是函式呼叫運算子。

因此它等價於：

min(number1, number2, number3);

前提是 min 已經被宣告為適當的函式指標。

另外，函式呼叫運算子 () 的優先順序高於解參照運算子 *，所以：

*min(number1, number2, number3);

會被解讀成：

*(min(number1, number2, number3));

而不是呼叫 min 所指向的函式。因此使用 (*min) 的括號，可以明確表示「先取得指標所指向的函式，再進行呼叫」。

選項分析

(a) It is the header for function min.

錯誤。

函式標頭通常包含函式名稱、參數列與回傳型別，例如：

int min(int a, int b, int c)

核心觀念
在 C++ 中，類別的繼承關係會影響「is‑a」與「has‑a」的語意判斷。

• is‑a 關係：子類別物件可以在任何需要父類別物件的情境下使用，亦即子類別「是」父類別的一種。
• 可見性（inheritance specifier）：public、protected、private 三種繼承方式決定了基底類別成員在衍生類別中的存取權限，同時也決定了衍生類別與基底類別的「is‑a」關係是否對外部程式碼成立。

解題方法
判斷每種繼承方式是否保留「is‑a」關係，只需檢視「衍生類別指標或參考」能否隱式轉換成「基底類別指標或參考」：

• public 繼承：轉換公開，外部程式碼可直接把衍生類別指標/參考視為基底類別指標/參考，構成完整的 is‑a。
• protected 繼承：轉換仍然存在，但僅限於衍生類別本身與其子類別內部，外部程式碼無法使用，因此不構成對外的 is‑a。
• private 繼承：轉換僅在衍生類別內部可見，外部程式碼完全無法利用，亦不形成 is‑a。

因此，只有 public 繼承在所有情境下皆可視為 is‑a。

選項分析
(a) Only public.

• 正確。public 繼承保留了基底類別的公有介面，使得衍生類別在任何使用基底類別的地方都能替代，符合「is‑a」語意。

本題考驗對 C++ 中虛函數 (virtual function) 和純虛函數 (pure virtual function) 的區別的理解。

核心觀念：虛函數與純虛函數。

• 虛函數 (Virtual Function)：

  • 在基底類別中使用 virtual 關鍵字聲明的函數。
  • 允許在派生類別中被覆寫 (override)。
  • 基底類別的虛函數可以有自己的實現（定義）。
  • 用於實現多型 (polymorphism)。
  • 聲明語法：virtual return_type function_name(parameters);

• 純虛函數 (Pure Virtual Function)：

  • 在基底類別中使用 virtual 關鍵字聲明，並將其定義設置為純虛函數。
  • 純虛函數的聲明語法是：virtual return_type function_name(parameters) = 0;
  • 它沒有函數體（實現），只有聲明。
  • 純虛函數強制要求所有派生類別（除非派生類別也是抽象類別）必須提供自己的實現。
  • 包含純虛函數的類別稱為抽象類別 (Abstract Class)。抽象類別不能被實例化（創建物件）。
  • 純虛函數也是為了實現多型。

本題考驗對 C++ 模板 (template) 的理解，特別是類模板 (class template) 的成員函數定義時，如何使用範圍解析運算符 ::。

核心觀念：C++ 類模板的成員函數定義。
在 C++ 中，類模板的成員函數定義通常需要寫在類別外部。當我們定義一個類模板的成員函數時，需要指明該函數屬於哪個模板類別，以及該模板類別的模板參數。

語法：
template <template_parameters> return_type ClassName<template_arguments>::member_function_name(parameters) { ... }

其中：

• template <template_parameters>：聲明這是一個模板定義。
• ClassName<template_arguments>：指明這個成員函數屬於哪個類模板的哪個實例。template_arguments 是模板參數的具體類型。
• ::：範圍解析運算符，用於指明 member_function_name 是 ClassName<template_arguments> 的成員。

何時需要 ::？
當成員函數的定義寫在類別聲明（prototype）的外部時，就需要使用範圍解析運算符 :: 來指定該函數屬於哪個類別。這適用於普通類別，也同樣適用於類模板。

對於類模板，當我們定義其成員函數時，不僅需要類別名稱，還需要指定模板參數。
例如：

本題要求實作一個 C++ 程式，使用選擇排序法 (Selection Sort) 對一組整數進行排序，並透過傳引用 (pass-by-reference) 的方式來達到效率和修改原始資料的目的。程式需要包含兩個函數：一個用於讀取整數（readFunc，只需提供宣告），另一個用於排序（selectionSort，需要實作）。

核心觀念：

1. 選擇排序法 (Selection Sort)：一種簡單的排序演算法。其基本思想是：每次從未排序的部分找到最小（或最大）的元素，放到已排序部分的末尾。
2. 傳引用 (Pass-by-Reference)：在 C++ 中，通過在函數參數中使用引用符號 &，可以讓函數直接操作傳遞進來的原始變數，而不是其副本。這對於修改原始資料或處理大型物件以提高效率非常有用。
3. 函數宣告 (Function Declaration/Prototype)：告訴編譯器函數的名稱、返回類型和參數類型，但不需要提供函數的具體實現。
4. 函數定義 (Function Definition)：包含函數的具體實現（程式碼）。

程式架構：

• main 函數：負責程序的整體流程，包括呼叫 readFunc 讀取數據，呼叫 selectionSort 排序，以及輸出排序後的結果。
• readFunc 函數：負責從輸入讀取整數，並將它們存儲到一個容器中。題目要求只需提供其聲明。
• selectionSort 函數：負責接收一個整數陣列（或向量）的引用，並對其進行原地排序。

實作步驟：

1. 包含必要的標頭檔：

   • iostream 用於輸入輸出。
   • vector 用於動態陣列（推薦使用，比 C 風格陣列更靈活）。
   • algorithm 如果需要使用 swap 函數（雖然也可以手動實現）。

2. readFunc 函數宣告：
   根據題目要求，我們需要宣告 readFunc。它應該接收一個整數向量的引用，以便將讀取的數據填入其中。

   // Function declaration for readFunc
   // It takes a reference to a vector of integers and is expected to populate it.
   void readFunc(std::vector<int>& data);
   

   注意：這裡沒有提供函數體，滿足題目要求。

3. selectionSort 函數定義：
   這個函數需要接收一個整數向量的引用，並在其內部實現選擇排序。

   void selectionSort(std::vector<int>& arr) {
       int n = arr.size();
       // Outer loop iterates through the array to find the minimum element
       // for each position.
       for (int i = 0; i < n - 1; ++i) {
           // Assume the current index 'i' holds the minimum element
           int min_idx = i;
           // Inner loop finds the index of the minimum element in the
           // unsorted part of the array (from i+1 to n-1)
           for (int j = i + 1; j < n; ++j) {
               if (arr[j] < arr[min_idx]) {
                   min_idx = j; // Update index of minimum element
               }
           }
           // Swap the found minimum element with the element at index 'i'
           // if they are not already the same.
           if (min_idx != i) {
               std::swap(arr[min_idx], arr[i]);
               // Or manually:
               // int temp = arr[min_idx];
               // arr[min_idx] = arr[i];
               // arr[i] = temp;
           }
       }
   }
   

   演算法分析：

   • 時間複雜度：選擇排序法有兩個嵌套循環。外層循環執行 n-1 次，內層循環執行 n-1, n-2, ..., 1 次。總共的比較次數約為 $O(n^2)$。交換操作最多發生 n-1 次。因此，時間複雜度為 $O(n^2)$。
   • 空間複雜度：選擇排序法是一種原地排序演算法，它只需要常數額外的空間來儲存臨時變數（如 min_idx, temp）。因此，空間複雜度為 $O(1)$。

4. main 函數實現：

   • 創建一個 std::vector<int> 來儲存讀取的數據。
   • 調用 readFunc 函數，將向量的引用傳遞給它。
   • 調用 selectionSort 函數，將向量的引用傳遞給它進行排序。
   • 遍歷排序後的向量，並將每個元素輸出到控制台。

完整程式碼範例：