程式語言排名

Lambda 表達式

(參數) => 函數體

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector numbers = {1, 2, 3, 4, 5};

    // 使用 lambda 表達式來計算偶數的和
    int sum = 0;
    std::for_each(numbers.begin(), numbers.end(), [&sum](int n) {
        if (n % 2 == 0) sum += n;
    });

    std::cout << "偶數的總和: " << sum << std::endl;
    return 0;
}
        

# 使用 lambda 表達式來計算兩數的和
add = lambda x, y: x + y
print(add(5, 10))  # 輸出: 15
        

using System;
using System.Collections.Generic;
using System.Linq;

class Program {
    static void Main() {
        List numbers = new List { 1, 2, 3, 4, 5 };
        
        // 使用 Lambda 表達式篩選出偶數並計算總和
        int sum = numbers.Where(n => n % 2 == 0).Sum();
        
        Console.WriteLine($"偶數的總和: {sum}");
    }
}
        

Reflection

概念

常見用途

• 序列化/反序列化（JSON/XML ↔ 物件）
• 依賴注入（DI）/控制反轉（IoC）
• ORM（資料表 ↔ 物件欄位對應）
• 外掛/模組動態載入
• 測試框架（自動掃描測試、Mock）
• 驗證與自動產生表單/文件

優缺點

• 優點：高彈性、可減少樣板碼、支援通用框架設計。
• 缺點：效能較低、型別安全性降低、可見性破壞（可取用私有成員）、增加維護複雜度。

語言支援情況

• 完整支援：Python、C#、Java、Kotlin、JavaScript/TypeScript、Ruby、PHP、Go
• 部分支援：Swift（Mirror）、Scala
• 不支援（無 runtime 反射）：C++（至 C++23）、Rust（以 derive 宏或自訂程式碼生成替代）

典型範例

# Python：列舉並讀取物件屬性
class User:
    def __init__(self): self.id = 0; self.name = "Ann"
u = User()
for k, v in vars(u).items():
    print(k, v)  # id 0 / name Ann

// C#：取得欄位/屬性並讀值
using System;
using System.Reflection;

var t = typeof(MyType);
foreach (var p in t.GetProperties(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic))
    Console.WriteLine($"{p.Name}={p.GetValue(obj)}");

// JavaScript：動態列舉與呼叫
const obj = { x: 1, y: 2, add(){ return this.x + this.y; } };
for (const [k,v] of Object.entries(obj)) console.log(k, v);
console.log(obj["add"]()); // 3

// Java：使用反射讀/寫欄位
import java.lang.reflect.*;
class U { private int id = 42; }
U u = new U();
Field f = U.class.getDeclaredField("id");
f.setAccessible(true);
System.out.println(f.getInt(u)); // 42

// Go：reflect 走訪結構
import "reflect"
func Dump(v any) {
    val := reflect.ValueOf(v)
    for i := 0; i < val.NumField(); i++ {
        name := val.Type().Field(i).Name
        fmt.Println(name, val.Field(i).Interface())
    }
}

最佳實務

• 僅在確有彈性需求時使用（框架/工具層），避免濫用於核心熱路徑。
• 對敏感或私有成員的存取要審慎控管，遵循最小權限原則。
• 加入快取（例如快取成員資訊）以降低反射開銷。
• 搭配型別註解/屬性（Attributes/Annotations）明確意圖。

何時避免

• 效能關鍵路徑（可用事先生成程式碼或泛型/模板替代）。
• 需要強型別安全與可預期行為時（改用明確介面/抽象）。

檢查任意結構是否全為0

觀念總結

• 能否「自動」檢查任意結構取決於語言是否支援反射/內省（reflection/introspection）。
• 動態語言（如 Python、JavaScript、Ruby、PHP）最容易；靜態語言需靠 Reflection API（如 C#、Java、Kotlin、Go）。
• C++（至 C++23）與 Rust 無內建 runtime reflection，需手動為自訂型別撰寫檢查邏輯或以巨集/derive輔助。

語言支援度比較

Python 範例

def is_all_zero(obj, eps=1e-6):
    if isinstance(obj, (int, float)):  # 基本數值
        return abs(obj) < eps
    elif isinstance(obj, (list, tuple, set)):  # 序列/集合
        return all(is_all_zero(x, eps) for x in obj)
    elif isinstance(obj, dict):  # 字典
        return all(is_all_zero(v, eps) for v in obj.values())
    elif hasattr(obj, "__dict__"):  # 一般物件
        return all(is_all_zero(v, eps) for v in vars(obj).values())
    else:
        return False

# 測試
class Point: 
    def __init__(self, x=0, y=0): self.x, self.y = x, y
class Line:
    def __init__(self, p1=None, p2=None): 
        self.p1 = p1 or Point()
        self.p2 = p2 or Point()

print(is_all_zero([[0,0],[0,0]]))        # True
print(is_all_zero(Line(Point(0,0),Point(0,0))))  # True
print(is_all_zero(Line(Point(1,0),Point(0,0))))  # False

JavaScript 範例

function isAllZero(obj, eps = 1e-6) {
  const isNumZero = n => Math.abs(n) < eps;
  if (typeof obj === "number") return isNumZero(obj);
  if (Array.isArray(obj)) return obj.every(v => isAllZero(v, eps));
  if (obj && typeof obj === "object")
    return Object.values(obj).every(v => isAllZero(v, eps));
  return false;
}

console.log(isAllZero([[0,0],[0,0]]));     // true
console.log(isAllZero({x:0, y:{z:0}}));    // true
console.log(isAllZero({x:0.000001, y:0})); // 視 eps 而定

C# (.NET) 範例

using System;
using System.Linq;
using System.Reflection;

public static class ZeroCheck {
    public static bool IsAllZero(object obj, double eps = 1e-6) {
        if (obj == null) return true;
        switch (obj) {
            case int i:    return i == 0;
            case long l:   return l == 0;
            case float f:  return Math.Abs(f) < eps;
            case double d: return Math.Abs(d) < eps;
        }

        var t = obj.GetType();
        if (t.IsArray)
            return ((Array)obj).Cast<object>().All(x => IsAllZero(x, eps));

        // 掃描欄位與屬性
        foreach (var f in t.GetFields(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic))
            if (!IsAllZero(f.GetValue(obj), eps)) return false;

        foreach (var p in t.GetProperties(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic))
            if (p.CanRead && !IsAllZero(p.GetValue(obj, null), eps)) return false;

        return true;
    }
}

Go 範例

package main

import (
    "math"
    "reflect"
)

func IsAllZero(v interface{}, eps float64) bool {
    val := reflect.ValueOf(v)
    switch val.Kind() {
    case reflect.Float32, reflect.Float64:
        return math.Abs(val.Float()) < eps
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return val.Int() == 0
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        return val.Uint() == 0
    case reflect.Slice, reflect.Array:
        for i := 0; i < val.Len(); i++ {
            if !IsAllZero(val.Index(i).Interface(), eps) { return false }
        }
        return true
    case reflect.Map:
        for _, k := range val.MapKeys() {
            if !IsAllZero(val.MapIndex(k).Interface(), eps) { return false }
        }
        return true
    case reflect.Struct:
        for i := 0; i < val.NumField(); i++ {
            if !IsAllZero(val.Field(i).Interface(), eps) { return false }
        }
        return true
    case reflect.Pointer, reflect.Interface:
        if val.IsNil() { return true }
        return IsAllZero(val.Elem().Interface(), eps)
    default:
        return false
    }
}

C++ / Rust 的限制與做法

• C++（至 C++23）：無 runtime reflection。做法是為每個自訂型別撰寫 isAllZero，或用 template/巨集輔助展開成員。
• Rust：同樣無 runtime reflection，常以 derive 宏為型別自動生成實作（例如自訂 trait IsAllZero）。

實務建議

• 處理浮點數請加入容許誤差 eps，避免精度問題導致誤判。
• 若結構龐大，考慮在資料模型內提供明確的 isAllZero() 方法，避免昂貴的反射掃描。
• 在靜態語言（C++/Rust）可用單元測試確保每個新結構的檢查邏輯已涵蓋所有成員。

訊息佇列

定義與作用

訊息佇列 (Message Queue，簡稱 MQ) 是一種用於軟體系統之間異步通信的架構模式。它允許獨立的應用程式或服務透過傳送和接收訊息來交換資訊，而無需直接相互調用或依賴於對方的即時狀態。MQ 的核心作用是作為一個**中間層**，暫時儲存訊息，直到目標接收者準備好處理它們。

主要組成要素

• 發送者 (Producer/Publisher)： 產生並將訊息投遞到佇列或主題的應用程式。發送者在投遞訊息後，通常不會等待回覆，即可繼續執行自己的任務。
• 接收者 (Consumer/Subscriber)： 從佇列或主題中獲取訊息並進行處理的應用程式。接收者可以根據需求，隨時啟動或停止，而不會影響發送者的運作。
• 訊息代理 (Message Broker)： MQ 系統的核心伺服器。它負責接收、儲存、路由和傳遞訊息給正確的接收者。常見的 Broker 實作有 RabbitMQ、Kafka、ActiveMQ 等。

常見的訊息模式

訊息佇列的關鍵優勢

• 異步處理 (Asynchronous Processing)： 允許耗時操作在後台非同步執行，提升前端回應速度和用戶體驗。
• 系統解耦 (System Decoupling)： 消除服務間的直接依賴。發送者不需知道接收者的位置和狀態，使系統更具彈性和可維護性。
• 流量削峰 (Load Leveling/Peak Shaving)： 在高併發情境下，MQ 作為緩衝區，將瞬間的大量請求平滑地分散給後端服務處理，防止後端系統因超載而崩潰。
• 可靠性與冗餘 (Reliability and Redundancy)： 訊息通常會被持久化儲存。即使接收者暫時故障，訊息也不會丟失，待系統恢復後仍可繼續處理。

結語

訊息佇列是建構現代分佈式系統、微服務架構和高可用性應用程式的基石。它通過引入時間和空間上的間接性，顯著提高了系統的彈性、可伸縮性和穩健性。

訊息佇列與 HTTP API 比較

通信模式差異

適用情境比較

訊息佇列 (MQ) 的優勢與應用場景

• 流量削峰： 處理突發的大量請求，例如秒殺活動或大型促銷時的訂單提交。MQ 作為緩衝，保護後端服務不被瞬間流量擊垮。
• 異步處理： 執行耗時長或非即時的操作，例如用戶註冊後發送歡迎信件、日誌處理、生成報表等。
• 系統解耦： 微服務架構中，將不同服務的生命週期和錯誤隔離開來，避免服務 A 的故障影響服務 B。
• 事件驅動架構： 當某個事件發生時（如訂單狀態變更），需要通知多個下游系統同時進行處理。

HTTP API 的優勢與應用場景

• 即時互動： 需要立即得到回覆的場景，例如使用者登入、查詢即時庫存、金融交易的即時確認。
• 請求-回應模式： 需要雙向互動並根據伺服器的回覆進行下一步操作的場景。
• 簡單性： 對於簡單的 CRUD（增、查、改、刪）操作，HTTP API 的開發和測試相對直接和快速。
• 客戶端應用： 網頁或手機 App 等前端應用程式，通常需要直接向後端發送同步請求並更新介面。

結論

MQ 和 HTTP API 並非互相取代的技術，而是針對不同問題而設計的。

• 如果需要立即獲得結果、要求同步，並且服務間的互動簡單明確，應選擇 HTTP API。
• 如果需要處理高併發、執行耗時操作、最大化系統解耦和容錯性，則應該使用訊息佇列。

在現代的分佈式系統中，兩種模式經常並存，互相配合以滿足不同的業務需求。

訊息佇列適合的應用實例

1. 異步任務處理

在許多網路應用中，有些操作是耗時的，如果讓使用者同步等待，會造成糟糕的使用者體驗。MQ 允許將這些任務轉為異步執行。

• 用戶註冊與通知： 當新用戶完成註冊時，核心系統只需將「用戶註冊成功」的訊息發送到佇列，立即回覆用戶端。後續的任務，如發送歡迎電子郵件、生成初始個人資料或積分發放，則由後端的消費者從佇列中取出訊息並慢慢執行。
• 長時計算與報表生成： 使用者請求生成一個包含大量數據的複雜報表或進行大規模資料計算。系統將請求推入 MQ，並立即告知使用者「報表正在生成中，完成後將以郵件通知」。後台服務異步完成計算。

2. 流量削峰與緩衝

MQ 在處理瞬時高流量的場景中至關重要，可以保護後端服務免於崩潰。

• 電子商務搶購/秒殺活動： 在高流量促銷活動中，瞬間湧入的數萬筆訂單提交請求會讓資料庫和後端訂單處理服務超載。MQ 將所有訂單請求接收並排隊。後端服務以其能處理的穩定速度從佇列中取出請求並處理，從而平滑了峰值壓力。
• 支付系統： 支付請求先進入 MQ。即使支付網關短暫超載，請求也不會丟失，而是安全地在佇列中等待被處理。

3. 系統解耦與微服務通信

在複雜的分佈式系統和微服務架構中，MQ 用於隔離服務，減少相互依賴。

• 訂單狀態變更通知： 當「訂單服務」成功建立新訂單後，它發出「新訂單建立」的事件訊息到 MQ 的主題。對此事件感興趣的多個服務（如「庫存服務」需要扣減庫存、「物流服務」需要準備發貨、「積分服務」需要計算積分）都會收到此訊息並各自獨立執行相應操作。
• 資料同步： 當主資料庫中的某個重要資料被更新時，可以發送一個變更事件到 MQ，允許其他下游系統（例如搜尋索引服務、數據倉庫）訂閱並非同步更新各自的資料副本，實現最終一致性。

4. 日誌收集與監控

將大量的日誌資料從前端應用程式或伺服器收集到集中的處理系統。

• 日誌彙集： 數百個應用程式伺服器不斷產生日誌資料。這些日誌不會直接寫入分析資料庫，而是先發送到 MQ（例如使用 Apache Kafka）。集中的日誌處理服務（如 Logstash）從 MQ 中消費日誌，進行清洗、轉換和索引，最終存入 Elasticsearch 等儲存。這隔離了日誌發送與處理的過程。

5. 數據串流處理

特別是像 Apache Kafka 這樣的高吞吐量 MQ/串流平台，非常適合處理連續不斷的即時資料流。

• 物聯網 (IoT) 數據： 數百萬個感測器和設備持續產生溫度、位置或狀態數據。MQ 可以高效地接收這些數據流，並將其傳遞給即時監控系統或數據分析管道。

HTTP API 傳輸圖片與影片

傳輸大型二進位資料的挑戰

使用 HTTP API 傳輸圖片 (Images) 和影片 (Videos) 這些大型二進位資料 (Binary Data)，主要的挑戰在於：

• 大小限制： 單個檔案通常很大，可能超過伺服器或網路設定的請求主體 (Request Body) 大小限制。
• 時間限制： 傳輸大檔案耗時較長，容易導致 HTTP 請求超時 (Timeout)。
• 效率與編碼： 傳統的 JSON 或 XML 不適合傳輸二進位資料，需要使用高效的編碼方式。

HTTP API 上傳（發送）圖片/影片的方法

1. 使用 multipart/form-data 格式 (最常用於檔案上傳)

這是瀏覽器或客戶端應用程式上傳檔案最標準和最常用的方法。

• 原理： 將整個 HTTP 請求主體分成多個部分 (Part)，每個部分可以包含不同的欄位資料（如文字、數字）或一個完整的檔案。
• 優點： 通用性強，大多數 Web 框架和伺服器都原生支持處理此格式。可以一次請求上傳多個檔案和相關的元資料 (Metadata)。
• Content-Type 範例： multipart/form-data; boundary=YourBoundaryString

2. 直接使用二進位主體 (Binary Body)

如果只需上傳一個單一檔案，可以直接將檔案的二進位內容作為請求的主體。

• 原理： 請求的主體只包含檔案的原始位元組 (Raw Bytes)。
• 優點： 簡單直接，沒有額外的表單邊界 (Boundary) 開銷，傳輸效率高。
• Content-Type 範例： 圖片：image/jpeg 或 image/png；影片：video/mp4。

3. 使用 Base64 編碼 (不建議用於大檔案)

將二進位資料轉換成 ASCII 字串，嵌入到 JSON 或 XML 等文本格式中傳輸。

• 優點： 易於嵌入到標準的 JSON 請求中，無需更改 Content-Type，處理簡單文字格式的 API 也能支援。
• 缺點： Base64 編碼會使檔案體積增大約 33%，**極不適合**傳輸大型影片或高畫質圖片，會大幅增加傳輸時間和伺服器解碼開銷。

HTTP API 下載（接收）圖片/影片的方法

下載二進位資料相對簡單，伺服器直接將檔案的原始二進位內容作為 HTTP 回應的主體 (Response Body) 返回。

• 伺服器回應： 伺服器必須設定正確的 HTTP Header：
  • Content-Type： 必須指明檔案的 MIME 類型，例如 image/jpeg 或 video/mp4。
  • Content-Disposition： 通常設定為 attachment; filename="example.mp4"，指示瀏覽器將內容作為檔案下載而非直接顯示。

影片傳輸的優化：分塊傳輸與串流

對於特別大的檔案（尤其是影片），推薦使用以下技術來提高可靠性和效率：

• 分塊上傳 (Chunked Upload)： 客戶端將大檔案分割成多個較小的塊 (Chunks)，分別通過 HTTP 請求上傳，最後由伺服器組裝。這可以避免單次請求超時，並方便續傳。
• 位元組範圍請求 (Byte Range Requests)： 下載時，客戶端可以使用 HTTP Header Range 請求檔案的特定片段（例如 Range: bytes=100-200）。這對於影片串流 (Streaming) 非常重要，允許播放器只下載需要播放的部分，並支持快進/快退。

串流關鍵技術

1. 傳輸協議 (Protocols)

串流傳輸的核心在於如何高效、穩定且低延遲地將影音內容從伺服器傳輸到客戶端。

• HTTP Live Streaming (HLS)： 由 Apple 開發，是目前最普及的串流標準之一。它將影音切分成小的 $\texttt{.ts}$（MPEG Transport Stream）或 $\texttt{.fmp4}$（Fragmented MP4）檔案片段，並使用一個 $\texttt{.m3u8}$ 播放列表來管理這些片段。
  • 優點： 相容性極高（幾乎所有裝置和瀏覽器都支援），易於通過標準 HTTP 快取和 CDN 加速。
• MPEG-DASH (Dynamic Adaptive Streaming over HTTP)： 一個國際標準，功能與 HLS 相似，也採用 HTTP 傳輸和片段化技術，使用 $\texttt{.mpd}$ 檔案作為媒體描述。
  • 優點： 具備高度的彈性和功能性，是 Android 裝置和許多非 Apple 平台的常用選擇。
• WebRTC (Web Real-Time Communication)： 專為實現**超低延遲**的即時通訊而設計，例如視訊會議、直播互動和線上遊戲。它通常使用 UDP 進行資料傳輸。
  • 優點： 延遲極低（毫秒級），點對點 (P2P) 或近點對點傳輸。
• RTMP (Real-Time Messaging Protocol)： 傳統的 Adobe Flash 協議。雖然已逐漸被 HLS/DASH 取代，但仍廣泛用於直播**推流端**（從編碼器推送到串流伺服器）。

2. 核心技術與概念

適應性位元速率 (Adaptive Bitrate Streaming, ABR)

這是現代串流服務的基石。伺服器會將同一段影音內容編碼成多個不同品質（位元速率、解析度）的版本。

• 原理： 客戶端（播放器）會根據自己的網路頻寬和 CPU 負載，**動態地**切換到最高能流暢播放的品質版本。
• 效益： 提供最佳使用者體驗，避免緩衝 (Buffering) 和卡頓。

內容傳遞網路 (Content Delivery Network, CDN)

對於面向全球使用者的串流服務來說，CDN 是不可或缺的。

• 原理： 將影音內容（HLS/DASH 片段）分發並快取到全球各地的邊緣節點伺服器。
• 效益： 使用者從地理位置最近的伺服器獲取內容，大幅降低延遲，提高傳輸速度，並分擔原始伺服器的負載。

影音編解碼器 (Codecs)

用於壓縮和解壓縮影音資料，以減少檔案大小。

• 影片： H.264 (AVC)、H.265 (HEVC)、AV1。H.265 和 AV1 提供比 H.264 更高的壓縮效率，能以更小的檔案大小提供相同的畫質。
• 音訊： AAC (Advanced Audio Coding) 是串流中最常用的音訊編解碼器。

3. 內容保護與貨幣化

• 數位版權管理 (Digital Rights Management, DRM)： 用於保護版權內容不被非法複製和散播，確保只有授權使用者才能播放。常見標準包括 Widevine (Google)、PlayReady (Microsoft) 和 FairPlay Streaming (Apple)。
• 伺服器端廣告插入 (Server-Side Ad Insertion, SSAI)： 在串流內容到達客戶端前，就在伺服器端將廣告片段與主要內容拼接起來，有效繞過客戶端的廣告阻擋器 (Ad Blocker)。

Shell

Bash - $?

在 Bash 中，$? 代表上一個執行的命令的退出狀態碼（Exit Status）。這是一個整數值，通常用來判斷上一個命令是否成功執行。

退出狀態碼的意義

• 0：表示命令成功執行。
• 非 0：表示命令執行失敗，不同的非 0 值可以代表不同的錯誤類型。

範例 1：檢查成功執行的命令

#!/bin/bash
ls
echo "上一個命令的退出狀態碼是: $?"
    

在這個範例中，ls 命令會列出目錄內容，執行成功後，$? 的值將是 0。

範例 2：檢查失敗的命令

#!/bin/bash
ls /nonexistent-directory
echo "上一個命令的退出狀態碼是: $?"
    

在這個範例中，ls 嘗試列出不存在的目錄，命令會失敗，$? 的值將是一個非 0 數字。

範例 3：使用退出狀態碼進行條件判斷

#!/bin/bash
cp file1.txt /some/directory/
if [ $? -eq 0 ]; then
    echo "文件複製成功。"
else
    echo "文件複製失敗。"
fi
    

此範例會根據命令的退出狀態來決定要顯示哪一條訊息。

Bash 中 if 條件語句的 AND / OR 用法

基本語法

if [ 條件 ]; then
    指令
fi

使用 AND（且）

要在 if 中同時滿足多個條件，可使用：

1. 使用 -a（過時但可用）

if [ "$a" -gt 0 -a "$b" -gt 0 ]; then
    echo "a 和 b 都大於 0"
fi

2. 使用 [[ ]] &&（推薦）

if [[ "$a" -gt 0 && "$b" -gt 0 ]]; then
    echo "a 和 b 都大於 0"
fi

3. 使用多重 if 配合 &&

if [ "$a" -gt 0 ] && [ "$b" -gt 0 ]; then
    echo "a 和 b 都大於 0"
fi

使用 OR（或）

只要其中一個條件成立即可執行：

1. 使用 -o（過時但可用）

if [ "$a" -eq 0 -o "$b" -eq 0 ]; then
    echo "a 或 b 為 0"
fi

2. 使用 [[ ]] ||（推薦）

if [[ "$a" -eq 0 || "$b" -eq 0 ]]; then
    echo "a 或 b 為 0"
fi

3. 使用多重 if 配合 ||

if [ "$a" -eq 0 ] || [ "$b" -eq 0 ]; then
    echo "a 或 b 為 0"
fi

混合使用 AND 與 OR

可搭配括號來控制優先順序：

if [[ ( "$a" -gt 0 && "$b" -gt 0 ) || "$c" -eq 1 ]]; then
    echo "a 和 b 都大於 0，或 c 等於 1"
fi

注意事項

• 使用 [[ ]] 時支援 && 和 ||
• 使用 [ ] 時建議搭配多個條件語句並用 && / ||
• 變數務必加上引號，避免空值造成錯誤

Bash 檢查變數是否為空

在 Bash 中，可以使用條件判斷來檢查變數是否為空，以下提供幾種常見的方式：

範例 1：使用 -z 檢查變數是否為空

#!/bin/bash

var=""
if [ -z "$var" ]; then
    echo "變數是空的"
else
    echo "變數不是空的"
fi
    

-z 用來檢查變數是否為空，如果變數為空，條件成立。

範例 2：使用 -n 檢查變數是否不為空

#!/bin/bash

var="some value"
if [ -n "$var" ]; then
    echo "變數不是空的"
else
    echo "變數是空的"
fi
    

-n 用來檢查變數是否不為空，如果變數有值，條件成立。

範例 3：使用雙引號比較來檢查變數是否為空

#!/bin/bash

var=""
if [ "$var" == "" ]; then
    echo "變數是空的"
else
    echo "變數不是空的"
fi
    

這種方式直接將變數與空字串進行比較，來檢查變數是否為空。

Bash 的陣列結構

簡介

Bash 支援兩種陣列：

• 索引陣列（Indexed Array）：以數字索引存取
• 關聯陣列（Associative Array）：以自訂字串鍵存取（需 Bash 4.0 以上）

索引陣列

定義方式

fruits=("apple" "banana" "cherry")

讀取元素

echo "${fruits[0]}"     # apple
echo "${fruits[1]}"     # banana

列出全部元素

echo "${fruits[@]}"

取得陣列長度

echo "${#fruits[@]}"

新增元素

fruits+=("date")

遍歷元素

for fruit in "${fruits[@]}"; do
    echo "$fruit"
done

關聯陣列

定義與使用（需 Bash 4+）

declare -A capital
capital["Taiwan"]="Taipei"
capital["Japan"]="Tokyo"

存取與遍歷

echo "${capital["Japan"]}"  # Tokyo

for key in "${!capital[@]}"; do
    echo "$key 的首都是 ${capital[$key]}"
done

注意事項

• 索引陣列索引從 0 開始
• 元素值建議用雙引號包起來，避免空白字元錯誤
• 關聯陣列必須使用 declare -A 宣告

結論

Bash 陣列是儲存多筆資料的重要結構，適合用於參數清單、目錄集、鍵值對等資料處理。

Bash 合併兩個陣列

基本語法

combined=("${array1[@]}" "${array2[@]}")

這會將兩個陣列中的所有元素合併為一個新陣列 combined。

完整範例

array1=("apple" "banana")
array2=("cherry" "date")

combined=("${array1[@]}" "${array2[@]}")

echo "合併後的陣列："
for item in "${combined[@]}"; do
    echo "$item"
done

合併至原陣列

array1+=("${array2[@]}")

這會將 array2 的內容直接加到 array1 後方。

注意事項

• 請務必使用 "${array[@]}" 形式，避免元素被錯誤展開
• 陣列中若有空白或特殊字元，用雙引號包住是必要的

Bash 判斷字串是否以某字開頭

使用字串模式比對（推薦）

str="hello world"

if [[ "$str" == hello* ]]; then
    echo "字串以 hello 開頭"
fi

說明： 使用 [[ ]] 支援 shell 的模式比對，* 代表任意字元。

使用正規表示式

if [[ "$str" =~ ^hello ]]; then
    echo "字串以 hello 開頭"
fi

說明： ^ 表示開頭，[[ ]] 中的 =~ 是正則運算。

使用 case 敘述

case "$str" in
  hello*) echo "字串以 hello 開頭" ;;
  *) echo "不是以 hello 開頭" ;;
esac

說明： case 是處理字串模式的好工具，簡潔且可讀性高。

使用 expr（舊式寫法）

if expr "$str" : '^hello' &> /dev/null; then
    echo "字串以 hello 開頭"
fi

說明： 使用 expr 的正則比對功能，適用於較舊版本的 shell。

注意事項

• 變數最好加上引號以防空字串錯誤
• [[ ]] 比 [ ] 功能更完整，推薦使用
• 使用 =~ 時可使用正則表達式，但記得不要加引號

Bash 判斷檔案或目錄是否存在與不存在

判斷是否存在：-e

-e 用來檢查檔案或目錄是否存在（不分類型）。

FILE="/etc/passwd"

if [ -e "$FILE" ]; then
    echo "$FILE 存在"
else
    echo "$FILE 不存在"
fi

判斷目錄是否不存在：! -d

-d 用來檢查是否為目錄，! 是否定運算。

DIR="/tmp/myfolder"

if [ ! -d "$DIR" ]; then
    echo "$DIR 不存在，正在建立..."
    mkdir -p "$DIR"
else
    echo "$DIR 已存在"
fi

其他常用的條件選項

• -e：檔案或目錄是否存在（不管是什麼類型）
• -f：是否為「一般檔案」
• -d：是否為「目錄」
• -L：是否為「符號連結」

範例：結合檢查與建立

PATH_TO_CHECK="/home/user/config"

if [ -e "$PATH_TO_CHECK" ]; then
    echo "$PATH_TO_CHECK 已存在"
else
    echo "$PATH_TO_CHECK 不存在，建立中..."
    mkdir -p "$PATH_TO_CHECK"
fi

建議

• 若只需知道「有無存在」→ 使用 -e
• 若需特別確認是目錄或檔案→ 使用 -d 或 -f
• 變數務必加上雙引號，避免空值或空格錯誤

列出所有子目錄存入陣列

範例：儲存到陣列

target_dir="/path/to/your/dir"
subdirs=()

while IFS= read -r -d $'\0' dir; do
    subdirs+=("$dir")
done < <(find "$target_dir" -mindepth 1 -maxdepth 1 -type d -print0)

說明

• find：列出子目錄（不遞迴）
• -mindepth 1：排除自身目錄
• -maxdepth 1：只列出第一層
• -type d：只列出目錄
• -print0 搭配 read -d $'\0'：處理有空格的路徑

範例輸出

for dir in "${subdirs[@]}"; do
    echo "$dir"
done

替代簡易寫法（若無特殊字元）

subdirs=( "$target_dir"/*/ )

此寫法使用通配符匹配子目錄，但無法排除檔案或處理空格與特殊字元。

取得包含 ~ 的實際路徑

方法一：使用 eval 展開

path="~/myfolder/file.txt"
realpath "$(eval echo "$path")"

方法二：以 $HOME 取代

path="~/myfolder/file.txt"
realpath "$(echo "$path" | sed "s|^~|$HOME|")"

方法三：使用 readlink

path="~/myfolder/file.txt"
readlink -f "$(eval echo "$path")"

建議用法

realpath "$(eval echo "$path")"

grep

基本搜尋

grep "關鍵字" 檔案名

忽略大小寫

grep -i "關鍵字" 檔案名

顯示行號

grep -n "關鍵字" 檔案名

遞迴搜尋

grep -r "關鍵字" 目錄路徑

只顯示符合的文字

grep -o "關鍵字" 檔案名

同時顯示檔名

grep -H "關鍵字" 檔案名

兩組關鍵字同時出現 (AND)

grep "關鍵字1" 檔案名 | grep "關鍵字2"

兩組關鍵字任一出現 (OR)

# 方法一：正規表示式
grep -E "關鍵字1|關鍵字2" 檔案名

# 方法二：多個 -e 參數
grep -e "關鍵字1" -e "關鍵字2" 檔案名

解決 binary file matches 問題

# 方法一：強制將檔案視為文字
grep -a "關鍵字" 檔案名

# 方法二：轉換檔案編碼為 UTF-8 再搜尋
iconv -f 原始編碼 -t UTF-8 檔案名 | grep "關鍵字"

# 範例 (從 BIG5 轉成 UTF-8)
iconv -f BIG5 -t UTF-8 檔案名 | grep "關鍵字"

常用組合

grep -rin "關鍵字" 目錄路徑

-print0 搭配 read -d $'\0' 的詳解與範例

用途說明

在處理包含空格、特殊符號（如空白、引號、換行）的檔名或路徑時，傳統使用 find 配管線 xargs 或 read 可能產生誤判。

-print0 可讓 find 以 null（\0）字元作為輸出分隔，而 read -d $'\0' 能精準讀取 null 分隔的內容，確保每個檔案/路徑準確分離。

基本範例：收集所有子目錄

subdirs=()
while IFS= read -r -d $'\0' dir; do
    subdirs+=("$dir")
done < <(find . -type d -print0)

說明

• -print0：將每筆結果用 null 字元結尾，不用換行
• -d $'\0'：read 每次讀取一個 null 結尾的項目
• IFS=：避免空格被當成欄位分隔
• -r：避免處理時跳脫字元

範例 1：列出所有 .txt 檔案絕對路徑

txt_files=()
while IFS= read -r -d $'\0' file; do
    txt_files+=("$file")
done < <(find "$(pwd)" -type f -name "*.txt" -print0)

範例 2：將檔案傳送到某命令處理（安全）

find . -type f -print0 | while IFS= read -r -d $'\0' file; do
    echo "處理：$file"
    # your_command "$file"
done

範例 3：僅處理包含空格的目錄

find . -type d -print0 | while IFS= read -r -d $'\0' dir; do
    if [[ "$dir" == *" "* ]]; then
        echo "含空格的目錄：$dir"
    fi
done

為何不用換行？

傳統用法如：

find . -type f | while read file; do ...

但若檔名內含換行，會導致 read 錯誤解析，甚至多行誤判為多個檔案。

結論

• -print0 與 read -d $'\0' 是處理任何檔名最安全的方式
• 避免空格、特殊字元或換行導致的處理錯誤
• 適用於 Bash 陣列收集、迴圈處理、xargs 搭配 -0 等場景

while read 只取得一個目錄的問題

問題說明

以下寫法在某些 Bash 或 Cygwin 環境中，只讀取第一個項目：

while IFS= read -r -d $'\0' dir; do
    subdirs+=("$dir")
done < <(find "$target_dir" -mindepth 1 -maxdepth 1 -type d -print0)

這通常是因為 `<(find ...)` 在某些系統（如 Cygwin）不是「真正的檔案描述符」，造成 `read` 無法持續讀取。

修正方式：使用管線搭配 `read -d ''`（或 `readarray -d`）

方法 1：使用 `find | while` 管線搭配 -print0

subdirs=()
find "$target_dir" -mindepth 1 -maxdepth 1 -type d -print0 | while IFS= read -r -d $'\0' dir; do
    subdirs+=("$dir")
done

**注意**：若希望 `subdirs` 在主程式中可用，這方法不適合（因 `while ... |` 子 shell 無法回傳陣列）

方法 2：改存為陣列再處理

mapfile -d '' -t subdirs < <(find "$target_dir" -mindepth 1 -maxdepth 1 -type d -print0)

mapfile（或 readarray）可正確讀入 null 分隔字串為陣列。
這是最可靠且能保留在主 shell 中的方式。

範例輸出

for dir in "${subdirs[@]}"; do
    echo "找到目錄：$dir"
done

總結

• mapfile -d '' -t 是處理 -print0 最安全且最 Bash 原生的方式
• 避免使用管線會導致陣列作用範圍侷限於子 shell
• 注意某些舊版本 Bash 或非 Linux 環境可能不支援 `<( ... )` 正常工作

從變數內容讀取資料（用 read）

假設變數中有多行文字內容

var="line1
line2
line3"

用 while read 逐行讀取

while IFS= read -r line; do
    echo "讀到：$line"
done <<< "$var"

解說

• IFS= 避免 trim 空白
• -r 避免跳脫字元被解析
• <<< 是 here-string，將變數內容當成輸入給 while

單行讀取

read -r first_line <<< "$var"
echo "第一行為：$first_line"

讀成陣列

readarray -t lines <<< "$var"
for line in "${lines[@]}"; do
    echo "$line"
done

找出以 abc 開頭的子目錄並依日期排序

完整指令（依目錄修改時間排序）

find . -mindepth 1 -maxdepth 1 -type d -name "abc*" -printf "%T@ %p\n" | sort -nr | cut -d' ' -f2-

說明

• -mindepth 1 -maxdepth 1：只列出當前目錄下的子目錄
• -name "abc*"：名稱以 abc 開頭
• -printf "%T@ %p\n"：印出修改時間（timestamp）與目錄名稱
• sort -nr：依時間數值由新到舊排序
• cut -d' ' -f2-：去掉時間戳，只顯示路徑

範例輸出

./abc_latest
./abc_old
./abc_2020

若需存入 Bash 陣列

readarray -t abc_dirs << <(
  find . -mindepth 1 -maxdepth 1 -type d -name "abc*" -printf "%T@ %p\n" |
  sort -nr | cut -d' ' -f2-
)

for dir in "${abc_dirs[@]}"; do
  echo "找到：$dir"
done

附註

• -printf 為 GNU find 專屬功能，在 macOS 預設 find 不支援，可用 gfind 替代
• %T@ 代表「最後修改時間（秒）」，若需建立時間，需額外工具

Bash 檢查儲存裝置是否可寫入

方法 1：檢查目錄是否有寫入權限

DIR="/mnt/usb"

if [ -w "$DIR" ]; then
    echo "$DIR 可寫入"
else
    echo "$DIR 不可寫入"
fi

-w 為檢查目錄是否有「寫入權限」。但若目錄本身可寫，但實際裝置唯讀（如 mount 成 readonly），這方法可能失效。

方法 2：實際嘗試寫入測試檔案

DIR="/mnt/usb"
TESTFILE="$DIR/.write_test"

if touch "$TESTFILE" 2>/dev/null; then
    echo "$DIR 可寫入"
    rm "$TESTFILE"
else
    echo "$DIR 不可寫入"
fi

此方法最可靠，能檢測 mount 狀態或實體裝置是否真的可寫。

方法 3：使用 mount 指令檢查是否唯讀掛載

MNT="/mnt/usb"

if mount | grep "$MNT" | grep -q "(ro,"; then
    echo "$MNT 為唯讀掛載"
else
    echo "$MNT 為可寫掛載"
fi

此方法需檢查裝置是否被以唯讀（ro）方式掛載。

建議

• 若需保險，使用「方法 2」實際寫入測試法。
• 可搭配 udev 或 mount 時自動檢查。

Shell 重導向用法說明

1. 標準輸出重導向：`>`

在 Shell 中，使用 `>` 可以將指令的標準輸出（stdout）重導向到一個檔案或設備。若檔案已存在，內容會被覆蓋。

echo "Hello" > output.txt

這行指令將 "Hello" 寫入 output.txt 檔案。

2. 追加輸出重導向：`>>`

使用 `>>` 會將標準輸出附加到指定檔案的末尾，不會覆蓋原有內容。

echo "Hello again" >> output.txt

這行指令會將 "Hello again" 附加到 output.txt 的結尾。

3. 標準錯誤重導向：`2>`

在 Shell 中，`2>` 用於將標準錯誤（stderr）重導向到指定位置。例如：

ls non_existent_file 2> error.log

這行指令會將錯誤訊息寫入 error.log 檔案。

4. 追加錯誤重導向：`2>>`

若不想覆蓋錯誤訊息檔案，可使用 `2>>` 將錯誤訊息附加到檔案末尾。

ls non_existent_file 2>> error.log

這行指令會將錯誤訊息附加到 error.log。

5. 同時重導向標準輸出與錯誤：`&>`

使用 `&>` 可以同時將標準輸出與標準錯誤都重導向到同一個檔案或設備。

command &> all_output.log

這行指令會將 command 的所有輸出（標準輸出與錯誤）寫入 all_output.log。

6. 合併標準錯誤到標準輸出：`2>&1`

`2>&1` 將標準錯誤合併到標準輸出，便於統一管理。例如：

command > output.log 2>&1

這行指令會將標準輸出和錯誤都寫入 output.log。

7. 禁止所有輸出：`>/dev/null 2>&1`

若不想顯示任何輸出，可將所有輸出導向到 /dev/null，如：

command >/dev/null 2>&1

這行指令會將 command 的所有輸出丟棄。

iconv - tee 輸出以 UTF-8 編碼寫入文件

在使用 tee 命令將輸出追加到文件時，可以通過 iconv 將輸出轉換為 UTF-8 編碼，確保文件內容以 UTF-8 保存。以下是具體的指令和範例。

指令格式

以下是將輸出保存為 UTF-8 編碼的 tee 指令格式：

• command：您要執行的命令。
• iconv -t utf-8：將輸出轉換為 UTF-8 編碼，其中 -t 代表「目標編碼」。
• tee -a output.txt：將轉換後的輸出追加到 output.txt 文件。

範例

以下範例演示如何將 ls 命令的輸出以 UTF-8 編碼寫入到 output.txt：

執行該指令後，output.txt 的內容將以 UTF-8 編碼保存，避免出現編碼錯誤。

Windows cmd

開啟方式

• 在開始選單搜尋「cmd」或「命令提示字元」
• 使用 Win + R 輸入 cmd 後按下 Enter
• 在資料夾路徑列輸入 cmd 可直接於該路徑開啟

常用指令

• dir：顯示目前目錄下的檔案與資料夾
• cd：切換目錄，例如 cd C:\Users
• cls：清除螢幕內容
• copy：複製檔案，例如 copy a.txt b.txt
• del：刪除檔案
• mkdir：建立新資料夾
• rmdir：刪除資料夾
• echo：輸出文字，例如 echo Hello
• exit：關閉命令提示字元

進階操作

• 重新導向輸出：dir > file.txt 將結果輸出至檔案
• 管線操作：dir | find "txt" 篩選包含 txt 的結果
• 批次檔：建立 .bat 檔案一次執行多個指令
• 環境變數：使用 set 查看與設定變數

管理員模式

• 搜尋「cmd」，右鍵選擇「以系統管理員身份執行」
• 可使用如 ipconfig /flushdns 或 sfc /scannow 等系統維護指令

cmd /k 後執行第二個指令

在同一個視窗執行多個指令

可以使用 &、&& 或 || 來接續指令：

cmd /k "第一個指令 & 第二個指令"

• &：無論第一個成功或失敗都會執行下一個
• &&：只有第一個成功時才執行下一個
• ||：只有第一個失敗時才執行下一個

呼叫其他批次檔

在第一個指令後加上 call，即可接續執行另一個批次檔：

cmd /k "第一個指令 & call second.bat"

使用 /c 執行後關閉

若不需要保持視窗開啟，可以用 /c：

cmd /c "第一個指令 & 第二個指令"

/c 會執行完所有指令後自動關閉視窗，而 /k 則會保留視窗。

CMD 中篩選關鍵字

使用 find 指令

• 在 CMD 中沒有 grep，但可以使用內建的 find 指令達到類似效果。
• 語法：指令 | find "關鍵字"

範例

dir | find "txt"          :: 只顯示包含 "txt" 的檔案列
ipconfig | find "IPv4"    :: 只顯示含有 IPv4 的行
tasklist | find "chrome"  :: 篩出含有 chrome 的執行程序

常用參數

• /I：忽略大小寫，例如 find /I "error"
• /V：顯示未包含關鍵字的行
• /C：只顯示符合的行數

多關鍵字搜尋

• 可串接多個 find 達成 AND 條件：

type log.txt | find "Error" | find "2025"

• 若要達成 OR 條件，可用 findstr：

type log.txt | findstr /I "error warning fail"

進階：使用 findstr

• findstr 是 CMD 版的進階搜尋工具，支援多關鍵字與正規表示式。
• 範例：

dir | findstr /R ".*\.txt$"   :: 使用正規表示式找出 .txt 檔
type log.txt | findstr /I "timeout error fail"

CMD 啟動時自動執行的設定方式

概念說明

• 在 Linux 中，登入新 bash 時會自動執行 ~/.bash_profile 或 ~/.bashrc。
• 在 Windows CMD 中，沒有完全對等的「.bash_profile」，但可以用幾種方式達到類似效果。

方法一：使用 AutoRun 登錄值

• CMD 啟動時會檢查系統登錄表中的 AutoRun 設定，若有內容會自動執行。

HKEY_CURRENT_USER\Software\Microsoft\Command Processor
HKEY_LOCAL_MACHINE\Software\Microsoft\Command Processor

• 建立或修改字串值 AutoRun，內容可設定為要執行的批次檔路徑：

AutoRun = "C:\Users\YourName\cmd_startup.bat"

• 此批次檔會在每次開啟 CMD 時自動執行。

方法二：修改 CMD 快捷方式

• 右鍵 CMD 快捷方式 → 屬性 → 「目標」欄位修改：

%SystemRoot%\System32\cmd.exe /k "C:\Users\YourName\cmd_startup.bat"

• /k 代表啟動後執行該批次檔並保持視窗開啟。

方法三：使用登入啟動批次檔

• 將啟動批次檔放入：

%AppData%\Microsoft\Windows\Start Menu\Programs\Startup

• 這樣在登入 Windows 帳號時會自動執行，但這是系統層級的自動啟動，而非每次 CMD 開啟。

對應說明

自動設定 CMD AutoRun 的批次檔

功能說明

• 此批次檔會檢查登錄路徑 HKEY_CURRENT_USER\Software\Microsoft\Command Processor 是否存在。
• 若該路徑中沒有 AutoRun 值，則自動建立並設定為指定批次檔路徑。

範例批次檔內容

@echo off
setlocal

:: 設定 AutoRun 要執行的批次檔路徑
set "AUTORUN_PATH=C:\Users\%USERNAME%\cmd_startup.bat"
set "REG_PATH=HKCU\Software\Microsoft\Command Processor"

echo 檢查 CMD AutoRun 設定中...

:: 檢查登錄機碼是否存在
reg query "%REG_PATH%" >nul 2>&1
if errorlevel 1 (
    echo [資訊] 找不到 Command Processor 機碼，建立中...
    reg add "%REG_PATH%" /f >nul
)

:: 檢查 AutoRun 是否已設定
reg query "%REG_PATH%" /v AutoRun >nul 2>&1
if errorlevel 1 (
    echo [資訊] 未找到 AutoRun，建立新值...
    reg add "%REG_PATH%" /v AutoRun /d "%AUTORUN_PATH%" /f >nul
    echo [完成] AutoRun 已設定為：%AUTORUN_PATH%
) else (
    echo [OK] AutoRun 已存在，未做變更。
)

endlocal
pause

說明

• reg query：用來檢查登錄鍵或值是否存在。
• errorlevel：可用來判斷查詢結果是否成功 (0 為存在，1 為不存在)。
• reg add：建立登錄鍵或值。
• /f：強制覆蓋不提示。
• 可將 %AUTORUN_PATH% 改成你要在 CMD 啟動時自動執行的批次檔路徑。

判斷批次檔運行終端機

範例批次檔

@echo off

:: 偵測 PowerShell
if defined PSModulePath (
    echo 目前在 PowerShell 執行
    goto :eof
)

:: 偵測 Cygwin
if defined CYGWIN (
    echo 目前在 Cygwin 執行
    goto :eof
)
if defined SHELL (
    echo 目前在 Cygwin 執行 (SHELL=%SHELL%)
    goto :eof
)

:: 預設為 CMD
echo 目前在 CMD 執行

判斷依據

• PowerShell：批次檔在 PowerShell 中執行時，環境變數 PSModulePath 會存在
• Cygwin：通常會有 CYGWIN 變數，或 SHELL=/bin/bash
• CMD：若上述條件都不符合，即為傳統命令提示字元

PowerShell

開啟方式

• 在開始選單搜尋「PowerShell」
• 使用 Win + X 選擇「Windows PowerShell」或「Windows Terminal」
• 在資料夾路徑列輸入 powershell 可直接於該路徑開啟

常用指令

• Get-ChildItem：列出目前目錄檔案與資料夾 (類似 dir)
• Set-Location：切換目錄 (縮寫 cd)
• Clear-Host：清除螢幕內容 (縮寫 cls)
• Copy-Item：複製檔案或資料夾
• Remove-Item：刪除檔案或資料夾
• New-Item：建立新檔案或資料夾
• Write-Output：輸出文字 (縮寫 echo)
• Exit：關閉 PowerShell

進階操作

• 管線處理：Get-Process | Where-Object {$_.CPU -gt 100}
• 重新導向輸出：Get-ChildItem > file.txt
• 使用別名：例如 ls、cp、rm 可直接使用
• 變數使用：$var = "Hello"，輸出 $var
• 函式與腳本：可建立 .ps1 檔案執行多個指令

管理員模式

• 搜尋「PowerShell」，右鍵選擇「以系統管理員身份執行」
• 可執行如 Get-EventLog、Set-ExecutionPolicy 等系統維護指令

列出 PowerShell 中的所有變數

指令方法

• Get-Variable：顯示目前 PowerShell 工作階段中的所有變數
• Get-ChildItem variable:：透過變數驅動器檢視所有變數

範例

# 列出所有變數
Get-Variable

# 只顯示變數名稱
Get-Variable | Select-Object Name

# 顯示特定變數的值
Get-Variable PATH | Format-List *

# 使用變數驅動器方式
Get-ChildItem variable:

說明

• Get-Variable 預設會輸出名稱、值、描述等欄位
• 變數驅動器 variable: 可當作路徑來操作變數，例如 Get-Content variable:PATH
• 若要篩選，可以搭配 Where-Object，例如：
  Get-Variable | Where-Object { $_.Name -like "P*" } 只顯示以 P 開頭的變數

C與C++語言

高效能

• 與底層硬體的緊密結合，能直接操作記憶體與硬體資源。
• 程式碼執行速度快，適用於需要高效能的應用場景。

靜態型別系統

• 在編譯期間檢查型別錯誤，減少執行時錯誤的發生。
• 支援型別轉換以實現靈活的程式設計。

資源控制

• 提供精細的記憶體管理能力，允許開發者手動配置與釋放記憶體。
• 適合開發需要高效資源利用的嵌入式系統與即時應用。

語法靈活性

• 語法簡潔，提供高度控制的結構化設計能力。
• 支援多重編程範式，包括程序式與物件導向式。

廣泛應用領域

• C：用於系統程式設計、驅動程式、嵌入式開發。
• C++：用於遊戲開發、圖形處理、金融計算與大型軟體開發。

跨平台

• 在多數作業系統和硬體架構上均可使用。
• 提供高效能的同時，能滿足跨平台的需求。

C/C++ 預處理器指令

概述

預處理器指令 (Preprocessor Directives)是在 C 或 C++ 程式碼被編譯器正式處理（編譯）之前，由一個稱為「預處理器 (Preprocessor)」的程式模組所執行的命令。這些指令以井號（#）開頭，並且不以分號（;）結尾。

預處理器的作用是執行文字替換、檔案包含、條件編譯等操作，從而產生最終的「翻譯單元 (Translation Unit)」供編譯器使用。

主要指令類別與範例

1. 檔案包含 (File Inclusion)

用於將其他檔案的內容插入到當前檔案中。

• #include <filename>：用於包含標準程式庫標頭檔。預處理器會在編譯器預設的系統標頭檔路徑中搜尋檔案。
• #include "filename"：用於包含使用者自定義的標頭檔。預處理器會先在當前原始碼檔案的目錄中搜尋，然後才搜尋系統路徑。

#include <iostream>  // 包含標準 I/O 庫
#include "my_utility.h" // 包含自定義標頭檔

2. 巨集定義與替換 (Macro Definition and Substitution)

用於定義符號常數或代碼片段的文字替換巨集。

• #define：定義巨集。
• #undef：取消定義巨集。

#define MAX_SIZE 100 // 定義一個符號常數
#define SUM(a, b) ((a) + (b)) // 定義一個帶參數的巨集

int main() {
    int size = MAX_SIZE; // 預處理後變為 int size = 100;
    int total = SUM(5, 3); // 預處理後變為 int total = ((5) + (3));
    return 0;
}

3. 條件編譯 (Conditional Compilation)

允許根據預處理器巨集的值，來決定程式碼的特定區塊是否應被編譯。

• #ifdef：如果巨集已定義，則編譯後續區塊。
• #ifndef：如果巨集未定義，則編譯後續區塊。 (常用於 Include Guard)
• #if：根據給定的常數整數表達式的值來決定是否編譯。
• #else / #elif：條件編譯的替代或後續判斷。
• #endif：結束條件編譯區塊。

#define DEBUG_MODE 1

#if DEBUG_MODE
    std::cout << "偵錯模式已啟用" << std::endl;
#else
    std::cout << "生產模式運行中" << std::endl;
#endif

#ifndef MY_HEADER_H
#define MY_HEADER_H 
    // ... 標頭檔內容 (Include Guard 範例)
#endif

4. 錯誤與警告 (Error and Warning)

• #error：強制預處理器在遇到此指令時停止編譯，並顯示指定的錯誤訊息。
• #warning：輸出指定的警告訊息，但不停止編譯 (非標準指令，但許多編譯器支援)。

#ifndef VERSION_DEFINED
#error "必須定義版本號巨集 VERSION_DEFINED!"
#endif

5. 其他指令 (Other Directives)

• #pragma：用於向編譯器發送特殊指令，行為高度依賴於編譯器 (例如 #pragma once 和 #pragma warning)。
• #line：用於改變編譯器報告錯誤或警告時，所顯示的當前行號和檔案名稱。

#pragma once

定義與功能

#pragma once 是 C 和 C++ 語言中的一種預處理器指令 (Preprocessor Directive)。它的核心功能是確保包含此指令的標頭檔 (Header File) 在單次編譯過程中只會被編譯器處理一次。

此指令的目的是為了解決標頭檔重複包含的問題，防止因為多個原始碼檔案或多層級的標頭檔包含關係，導致同一段程式碼（例如類別定義、函式原型或常數宣告）被編譯器看到多次，進而引發重複定義 (Redefinition) 的編譯錯誤。

與 Include Guard 的比較

在 C/C++ 標準中，傳統上透過使用 Include Guard (包含衛兵) 來達到防止重複包含的目的。#pragma once 提供了更簡潔的替代方案。

Include Guard (標準方法)

這是標準且可移植的方法，使用條件編譯指令：

#ifndef MY_HEADER_H
#define MY_HEADER_H

// 標頭檔內容

#endif // MY_HEADER_H

它依賴於一個唯一的巨集名稱（例如 MY_HEADER_H）來控制內容是否被包含。

#pragma once (非標準方法)

使用單行指令：

#pragma once

// 標頭檔內容

編譯器會自動追蹤它在當前編譯會話中是否已經處理過這個檔案，如果處理過，則直接跳過該檔案的剩餘內容。

優點與缺點

#pragma once 的優點：

• 簡潔性： 只需一行程式碼，無需發明和維護唯一的巨集名稱。
• 編譯效率： 對於大型專案，由於編譯器可以直接根據檔案路徑判斷是否跳過，理論上可以提供略微的編譯速度提升。

#pragma once 的缺點：

• 非標準： 它不是 C++ 語言標準的一部分。儘管所有主流編譯器（包括 MSVC、GCC、Clang）都支援它，但在極少數或舊的編譯器上可能不被識別。
• 路徑依賴： 它依賴於編譯器能否正確識別檔案路徑的唯一性。在某些複雜的專案結構或符號連結環境中，可能會出現問題（雖然極為罕見）。

結論

在現代的開發環境中，特別是使用 Visual Studio 或主流編譯器時，#pragma once 因其簡潔和便利性，是防止標頭檔重複包含的常見且推薦的做法。

#pragma warning

定義與用途

#pragma warning 是 C 和 C++ 語言中的預處理器指令，專門用於在程式碼的特定區塊內，選擇性地抑制、恢復或修改編譯器警告的嚴重程度。

此指令的主要目的在於提供比專案級別設定更精細的控制。例如，當您需要包含一個會產生大量警告的舊版程式庫，但又不希望因此而全域性地關閉這些警告時，就可以使用此指令。

主要操作語法 (MSVC 格式)

雖然 #pragma warning 的具體實作在不同編譯器間可能略有差異（尤其 MSVC 使用最廣），但其核心動作分為以下幾種：

1. 禁用警告 (Disable)

從該點開始，編譯器將忽略指定的警告代碼。

#pragma warning( disable : 4996 ) // 禁用 C4996 (例如：關於使用不安全函式的警告)
// 包含或撰寫會產生 C4996 的程式碼

2. 恢復警告 (Default)

將指定的警告恢復到專案或命令列設定的預設行為。

#pragma warning( default : 4996 ) // 將 C4996 恢復為預設狀態

3. 儲存與還原狀態 (Push and Pop)

這是最安全且最推薦的模式。它允許在處理特定程式碼區塊時修改警告設定，然後確保原始的警告狀態在區塊結束後立即被還原，避免副作用。

• #pragma warning( push )：儲存當前的警告設定堆疊狀態。
• #pragma warning( pop )：還原到最近一次 push 所儲存的狀態。

#pragma warning( push )             // 1. 儲存目前的警告設定
#pragma warning( disable : 4996 4244 ) // 2. 禁用多個特定警告
// 包含第三方標頭檔或舊版程式碼
#pragma warning( pop )              // 3. 還原到原始設定
// 後續的程式碼將使用還原後的設定

4. 提升警告等級 (Error)

將特定的警告代碼提升為編譯錯誤，若發生該警告，編譯將失敗。

#pragma warning( error : 4005 ) // 將警告 4005 視為錯誤

注意事項

• 編譯器特有性： 警告編號（如 4996）是編譯器特定的。您必須針對您使用的編譯器（如 MSVC）查閱正確的編號。
• GCC/Clang 差異： 雖然 GCC 和 Clang 支援部分 #pragma warning 的功能，但它們通常更傾向於使用 -W... 命令列旗標或特殊的 #pragma GCC diagnostic 結構來控制警告。

C++ 標準命名空間

概述

在 C++ 程式設計中，std:: 是指 Standard Namespace（標準命名空間）。它是一個容器，包含了 C++ 語言核心和其標準程式庫（Standard Library）中的所有標準實體，包括函式、類別、模板、巨集和物件。

使用 std:: 的主要目的是為了避免命名衝突 (Name Collisions)。如果標準函式（例如 cout 或 vector）沒有被放在單獨的命名空間內，當使用者自己定義了同名的實體時，編譯器就會不知道該使用哪一個。

std:: 的主要內容

C++ 標準程式庫的大部分功能都位於 std:: 命名空間內。主要類別和功能包括：

1. 輸入/輸出串流 (I/O Streams)

• std::cout：標準輸出串流物件，用於將資料列印到控制台。
• std::cin：標準輸入串流物件，用於從控制台讀取資料。
• std::endl：輸出換行符並刷新緩衝區。
• std::ifstream / std::ofstream：檔案輸入/輸出串流。

2. 標準容器 (Containers)

用於儲存資料的集合類別：

• std::vector：動態大小的陣列。
• std::list：雙向連結串列。
• std::map：鍵值對的排序集合（紅黑樹實作）。
• std::unordered_map：鍵值對的無序集合（哈希表實作）。
• std::set：唯一鍵值的排序集合。
• std::string：用於處理字串的類別。

3. 演算法 (Algorithms)

一組用於容器和範圍操作的通用函式：

• std::sort：排序範圍內的元素。
• std::find：在範圍內尋找指定的值。
• std::copy：將元素從一個範圍複製到另一個範圍。

4. 其他核心工具 (Utilities)

• std::shared_ptr / std::unique_ptr：智慧型指標，用於自動化記憶體管理。
• std::thread：用於多執行緒程式設計。
• std::function：通用函式包裝器。
• std::pair / std::tuple：用於儲存固定數量不同類型值的模板。

使用 std:: 的方式

要存取 std:: 命名空間中的實體，有兩種主要方法：

1. 完整限定名稱 (Fully Qualified Names)

每次使用時都明確寫出 std:: 前綴。這是最安全且推薦的做法，尤其是在標頭檔中，以避免污染全域命名空間。

int main() {
    std::cout << "Hello World" << std::endl;
    std::vector<int> numbers;
    return 0;
}

2. using 宣告 (using Directives)

使用 using namespace std; 可以將整個 std:: 命名空間的內容引入到當前作用域，之後可以直接使用名稱而不需要 std:: 前綴。

#include <iostream>
using namespace std; // 將 std:: 命名空間引入

int main() {
    cout << "Hello World" << endl; // 不需 std:: 前綴
    vector<int> numbers;
    return 0;
}

儘管 using namespace std; 很方便，但在大型專案或標頭檔中應極力避免使用，因為它會增加命名衝突的風險。

檢查 std::vector 是否為空

概述

在 C++ 中，要檢查 std::vector 容器是否不包含任何元素（即大小為零），最標準且推薦的方法是使用其成員函式 empty()。這是因為 empty() 函式通常比直接檢查 size() 是否等於零更高效，特別是在某些容器實作中。

檢查方法

1. 使用 empty() 函式 (推薦)

這是檢查 vector 是否為空的首選方法。它返回一個布林值：如果 vector 沒有元素，則返回 true；否則返回 false。

#include <vector>
#include <iostream>
#include <string>

void check_empty(const std::vector<std::string>& vec)
{
    if (vec.empty()) {
        std::cout << "Vector 是空的 (empty() == true)." << std::endl;
    } else {
        std::cout << "Vector 不是空的 (empty() == false). 元素數量: " << vec.size() << std::endl;
    }
}

int main()
{
    std::vector<std::string> empty_vec;
    std::vector<std::string> non_empty_vec = {"apple", "banana"};

    check_empty(empty_vec);
    check_empty(non_empty_vec);

    return 0;
}

2. 檢查 size() 函式

雖然有效，但這不是檢查空狀態的最慣用或潛在最高效的方法。它直接檢查 vector 中的元素數量是否為零。

void check_size(const std::vector<int>& vec)
{
    if (vec.size() == 0) {
        std::cout << "Vector 是空的 (size() == 0)." << std::endl;
    } else {
        std::cout << "Vector 不是空的 (size() != 0)." << std::endl;
    }
}

效率考量

對於 std::vector 而言，empty() 和 size() == 0 在時間複雜度上都是 $O(1)$，因為 vector 會將其大小作為成員變數儲存。然而，對於某些其他 C++ 標準容器（例如 std::list 或 std::forward_list），標準建議始終優先使用 empty()，因為它通常是 C++ 標準容器庫中檢查空狀態的通用且最快的慣用法。

C++ 解析字串到字串向量

概述

在 C++ 中，要將一個包含空格（Space）或 Tab 字元（\t）分隔的字串解析成一個個獨立的單詞或標記，並儲存到 std::vector<std::string> 中，最常用的方法是利用 **std::stringstream**。檔案串流類別 std::stringstream 就像一個記憶體中的串流，它預設使用空白字元（包括空格、Tab 和換行符）作為分隔符來進行讀取操作。

程式碼範例

以下是使用 std::stringstream 完成此任務的 C++ 程式碼範例：

#include <iostream>
#include <sstream>   // 包含 stringstream
#include <string>
#include <vector>

using namespace std;

/**
 * 將輸入字串依據任何空白字元 (空格或 Tab) 分隔，並存入 vector。
 * @param input_str 要解析的字串。
 * @return 包含所有分離出的單詞的 vector。
 */
vector<string> split_string_by_whitespace(const string& input_str)
{
    vector<string> tokens;
    
    // 1. 建立 stringstream 物件，並用輸入字串初始化
    stringstream ss(input_str); 
    
    string token;
    
    // 2. 迴圈讀取
    // 串流提取運算子 (>>) 會自動以空白字元 (空格、Tab 等) 為分隔符讀取下一個 token。
    // 當成功讀取一個 token 時，運算子返回 true，否則 (到達字串結尾) 返回 false。
    while (ss >> token) 
    {
        tokens.push_back(token);
    }
    
    return tokens;
}

int main()
{
    // 輸入字串包含多個空格和 Tab 符號 (\t)
    string test_string = "Hello \tWorld   this is \ta test string";
    
    cout << "原始字串: " << test_string << endl;
    
    vector<string> result = split_string_by_whitespace(test_string);
    
    cout << "--- 分隔結果 ---" << endl;
    
    for (size_t i = 0; i < result.size(); ++i)
    {
        cout << "Token " << i + 1 << ": [" << result[i] << "]" << endl;
    }
    
    return 0;
}

關鍵機制解釋

• std::stringstream ss(input_str)：這個類別將輸入字串視為一個輸入串流 (Input Stream)，功能類似於從檔案讀取時使用的 std::ifstream。
• 串流提取運算子 (>>)：
  • 它是 C++ 輸入串流的核心機制。
  • 它會自動忽略任何前導的空白字元（包括空格、Tab、換行符等）。
  • 它會讀取所有連續的非空白字元，直到遇到下一個空白字元或串流結尾。
  • 這完美地符合了「依任何空白字元分隔」的要求，並自動處理多個連續分隔符的情況。
• while (ss >> token)：這是一個慣用的 C++ 串流讀取迴圈。只要串流成功提取並將數據儲存到 token 變數中，迴圈就會繼續執行。

.NET 與 std str 轉碼亂碼

原因

在 C++/CLI 中，gcnew System::String(stdStr.c_str()) 會將 std::string（通常是 ANSI / UTF-8 編碼）直接轉成 .NET System::String，而 System::String 預期是 UTF-16。
如果 stdStr 內含非 ASCII 字元（例如中文），就會出現亂碼。

解法一：使用 marshal_as（建議）

需引用命名空間：

#include <msclr/marshal_cppstd.h>
using namespace msclr::interop;

std::string stdStr = "中文測試";
System::String^ netStr = marshal_as<System::String^>(stdStr);

✅ 此方法能自動依 UTF-8 / ANSI 正確轉成 .NET Unicode。

解法二：如果確定 std::string 是 UTF-8，可手動轉換

#include <codecvt>
#include <locale>

std::string utf8Str = u8"中文測試";
std::wstring wideStr = std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>{}.from_bytes(utf8Str);
System::String^ netStr = gcnew System::String(wideStr.c_str());

解法三：如果來源是 std::wstring

若 C++ 端原本使用寬字元字串，直接使用即可：

std::wstring wstr = L"中文測試";
System::String^ netStr = gcnew System::String(wstr.c_str());

建議

• 若 std::string 來源是 UTF-8（常見於現代系統）→ 用 marshal_as 或 codecvt。
• 若是舊 ANSI 字元編碼（例如本地編碼 Big5、Shift-JIS）→ 建議先在 C++ 轉成 UTF-8。
• 不要直接用 gcnew String(stdStr.c_str())，除非字串是純英文。

C++ 多維陣列初始化為 0

使用 std::array 初始化

在 C++ 中，可以使用 std::array 初始化多維陣列為 0：

#include <iostream>
#include <array>
using namespace std;

int main() {
    array<array<int, 4>, 3> arr = {0}; // 初始化所有元素為 0

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

注意事項

• std::array 是 C++ 標準庫中的容器類別，適合用於大小在編譯期固定的情況。
• 初始化時可以直接將元素設為 0，確保所有值都被清空。
• 與傳統陣列相比，std::array 提供更多的功能和安全性。

複製多維 std::array 的內容方法

問題情境

std::array<std::array<std::array<float, 2>, 2>, 2> twoLines;
std::array<std::array<std::array<float, 2>, 2>, 2> twoLinesCopy;

解法一：直接指定（= 運算子）

std::array 支援淺層到深層的完整複製，因此可以直接使用 =：

twoLinesCopy = twoLines;

解法二：使用 std::copy

std::copy(twoLines.begin(), twoLines.end(), twoLinesCopy.begin());

解法三：使用 std::memcpy（適合 POD 型別，這裡 float 適用）

std::memcpy(&twoLinesCopy, &twoLines, sizeof(twoLines));

建議

• 最簡單安全的方式：twoLinesCopy = twoLines;
• std::copy 適用於需要 STL 泛型方法。
• memcpy 僅適用於 POD（Plain Old Data），且無建構子/解構子邏輯。

.NET List

基本介紹

在 .NET（C++/CLI、C#、VB.NET 等語言）中，List<T> 是一個泛型集合類別， 可儲存任意型別的資料（T），並提供動態調整大小的功能。 它屬於 System::Collections::Generic 命名空間。

宣告與初始化

// 匯入命名空間
using namespace System;
using namespace System::Collections::Generic;

int main()
{
    // 宣告一個 List 儲存 int
    List<int>^ numbers = gcnew List<int>();

    // 初始化時直接加入元素
    List<String^>^ names = gcnew List<String^>({ "Alice", "Bob", "Charlie" });
}

新增、移除與存取元素

List<int>^ nums = gcnew List<int>();

// 新增元素
nums->Add(10);
nums->Add(20);
nums->Add(30);

// 插入指定位置
nums->Insert(1, 15); // 在索引 1 插入 15

// 移除指定值
nums->Remove(20);

// 移除指定索引
nums->RemoveAt(0);

// 取得元素
int value = nums[1]; // 取得索引 1 的元素

// 檢查是否包含
if (nums->Contains(30))
    Console::WriteLine("找到 30");

// 清空所有元素
nums->Clear();

遍歷 List

// for 迴圈
for (int i = 0; i < nums->Count; i++)
{
    Console::WriteLine("第 {0} 個元素: {1}", i, nums[i]);
}

// for each 迴圈
for each (int n in nums)
{
    Console::WriteLine(n);
}

常用屬性與方法

範例輸出

10
15
30

計算 List 的標準差

範例程式

#include <cmath>
#include <iostream>
using namespace System;
using namespace System::Collections::Generic;

int main()
{
    // 建立測試資料
    Dictionary<int, List<float>^>^ data = gcnew Dictionary<int, List<float>^>();
    data->Add(1, gcnew List<float>({ 1.2f, 2.3f, 3.4f }));
    data->Add(2, gcnew List<float>({ 4.5f, 5.5f, 6.5f, 7.5f }));
    data->Add(3, gcnew List<float>()); // 測試空清單

    // 計算每個 key 的標準差
    for each (KeyValuePair<int, List<float>^> entry in data)
    {
        int key = entry.Key;
        List<float>^ values = entry.Value;

        if (values == nullptr || values->Count == 0)
        {
            Console::WriteLine("Key {0}: 無資料", key);
            continue;
        }

        // 計算平均值
        double sum = 0.0;
        for each (float v in values)
        {
            sum += v;
        }
        double mean = sum / values->Count;

        // 計算變異數（母體變異數）
        double variance = 0.0;
        for each (float v in values)
        {
            double diff = v - mean;
            variance += diff * diff;
        }
        variance /= values->Count; // 若要樣本變異數，改為 (values->Count - 1)

        // 標準差
        double stddev = Math::Sqrt(variance);

        Console::WriteLine("Key {0}: 標準差 = {1:F4}", key, stddev);
    }

    return 0;
}

說明

• data：儲存每組浮點數列表的字典，key 為整數。
• mean：所有元素的平均值。
• variance：每個元素與平均值差的平方平均值。
• stddev：標準差為變異數的平方根。
• 若需樣本標準差，請將分母改為 values->Count - 1。

輸出結果範例

Key 1: 標準差 = 0.8981
Key 2: 標準差 = 1.1180
Key 3: 無資料

.NET Dictionary

基本介紹

在 .NET（C++/CLI、C#、VB.NET 等語言）中，Dictionary<TKey, TValue> 是一種泛型集合， 用於儲存「鍵值對 (key-value pair)」。每個 key 必須唯一，而 value 則可重複。 它屬於 System::Collections::Generic 命名空間。

宣告與初始化

// 匯入命名空間
using namespace System;
using namespace System::Collections::Generic;

int main()
{
    // 建立一個 Dictionary，Key 為 int，Value 為 String
    Dictionary<int, String^>^ users = gcnew Dictionary<int, String^>();

    // 直接初始化
    users->Add(1, "Alice");
    users->Add(2, "Bob");
    users->Add(3, "Charlie");

    return 0;
}

新增、修改、刪除與存取元素

Dictionary<String^, int>^ ages = gcnew Dictionary<String^, int>();

// 新增元素
ages->Add("Tom", 25);
ages->Add("Jerry", 30);

// 修改值（透過索引器）
ages["Tom"] = 26;

// 新增或修改（若 key 不存在則自動新增）
ages["Spike"] = 40;

// 刪除元素
ages->Remove("Jerry");

// 存取元素
if (ages->ContainsKey("Tom"))
{
    Console::WriteLine("Tom 的年齡是 {0}", ages["Tom"]);
}

// 嘗試取得值（避免例外）
int age;
if (ages->TryGetValue("Spike", age))
{
    Console::WriteLine("Spike 的年齡是 {0}", age);
}

遍歷 Dictionary

Dictionary<int, String^>^ users = gcnew Dictionary<int, String^>();
users->Add(1, "Alice");
users->Add(2, "Bob");
users->Add(3, "Charlie");

// 使用 KeyValuePair 迴圈
for each (KeyValuePair<int, String^> entry in users)
{
    Console::WriteLine("Key = {0}, Value = {1}", entry.Key, entry.Value);
}

// 只取 Keys
for each (int key in users->Keys)
{
    Console::WriteLine("Key: {0}", key);
}

// 只取 Values
for each (String^ name in users->Values)
{
    Console::WriteLine("Name: {0}", name);
}

常用屬性與方法

範例輸出

Key = 1, Value = Alice
Key = 2, Value = Bob
Key = 3, Value = Charlie
Tom 的年齡是 26
Spike 的年齡是 40

C++ 模板 (Template)

1. 什麼是模板 (Template)？

在 C++ 中，模板 (Template) 是一種泛型編程的工具，允許我們在編寫函數或類別時，不指定具體的資料型別，從而使程式碼更具重用性。模板有助於在單一程式碼中處理不同型別的資料，避免重複的函數或類別定義。

2. 函數模板 (Function Template)

函數模板允許我們撰寫可以處理不同型別的函數。函數模板的語法如下：

template <typename T>
T add(T a, T b) {
    return a + b;
}

在此例中，add 函數可以處理任何支持加法操作的型別，如 int、float 或 double。

使用時，可以這樣呼叫：

int result = add(3, 4);  // 使用 int 型別
double result2 = add(3.5, 2.7);  // 使用 double 型別

3. 類別模板 (Class Template)

類別模板允許我們建立可以適用於多種型別的類別。類別模板的語法如下：

template <typename T>
class MyClass {
private:
    T data;
public:
    MyClass(T data) : data(data) {}
    T getData() { return data; }
};

此例中的 MyClass 類別可以使用任何型別的資料作為 data。

使用時可以這樣：

MyClass<int> obj1(5);      // int 型別
MyClass<double> obj2(3.14);  // double 型別

4. 多個模板參數

模板可以接受多個參數，例如：

template <typename T, typename U>
class Pair {
private:
    T first;
    U second;
public:
    Pair(T first, U second) : first(first), second(second) {}
    T getFirst() { return first; }
    U getSecond() { return second; }
};

這樣的模板類別可以存儲兩種不同型別的資料：

Pair<int, double> pair1(1, 3.14);

5. 模板特化 (Template Specialization)

模板特化允許我們對特定型別的模板進行特別定義。例如：

template <>
class MyClass<int> {
public:
    MyClass(int data) { /* 特化行為 */ }
};

這段程式碼特化了 MyClass 對 int 型別的行為，使其與其他型別不同。

6. 非型別模板參數 (Non-Type Template Parameters)

模板還可以接受非型別的參數，例如常數值：

template <typename T, int Size>
class Array {
private:
    T data[Size];
public:
    int getSize() const { return Size; }
};

在這裡，Size 是一個非型別參數，表示陣列的大小。

使用範例：

Array<int, 10> arr;  // 建立大小為 10 的 int 型別陣列

7. 結論

C++ 模板功能強大，使得程式碼可以更具泛用性並減少重複。了解如何利用函數模板、類別模板及模板特化等技術，將大大提升程式設計的彈性與效能。

C++ 中互相參照的 Class 解決方案

// ClassA.h
#ifndef CLASSA_H
#define CLASSA_H

// 前向宣告 ClassB
class ClassB;

class ClassA {
public:
    ClassA();
    void setB(ClassB* b); // 設定指向 ClassB 的指標
    void showBData();      // 顯示 ClassB 的數據

private:
    ClassB* b; // 指向 ClassB 的指標
};

#endif
        

// ClassB.h
#ifndef CLASSB_H
#define CLASSB_H

// 前向宣告 ClassA
class ClassA;

class ClassB {
public:
    ClassB(int data);
    int getData();         // 取得數據
    void setA(ClassA* a);  // 設定指向 ClassA 的指標
    void showAInfo();      // 顯示 ClassA 的資訊

private:
    int data;
    ClassA* a; // 指向 ClassA 的指標
};

#endif
        

#include "ClassA.h"
#include "ClassB.h"
#include <iostream>

ClassA::ClassA() : b(nullptr) {}

void ClassA::setB(ClassB* b) {
    this->b = b;
}

void ClassA::showBData() {
    if (b != nullptr) {
        std::cout << "ClassB data: " << b->getData() << std::endl;
    }
}
        

#include "ClassB.h"
#include "ClassA.h"
#include <iostream>

ClassB::ClassB(int data) : data(data), a(nullptr) {}

int ClassB::getData() {
    return data;
}

void ClassB::setA(ClassA* a) {
    this->a = a;
}

void ClassB::showAInfo() {
    if (a != nullptr) {
        a->showBData();
    }
}
        

C++ Friend

在 C++ 中，friend 關鍵字可以用於函數或類別，以允許其他函數或類別訪問類別的私有成員（private）和保護成員（protected）。這樣的設計可讓外部函數或類別進行操作，而不違反封裝原則。

Friend 函數是一種被授權訪問另一類別的私有成員和保護成員的外部函數。在類別內部聲明時，以 friend 關鍵字修飾即可。

範例如下：

#include <iostream>
using namespace std;

class Box {
private:
    double width;

public:
    Box(double w) : width(w) {}

    // 聲明 friend 函數
    friend void showWidth(Box &b);
};

// friend 函數定義，能訪問 Box 類別的私有成員
void showWidth(Box &b) {
    cout << "Box 寬度: " << b.width << endl;
}

int main() {
    Box box(10.5);
    showWidth(box);  // 訪問私有成員 width
    return 0;
}
        

在此範例中，showWidth 函數雖然是 Box 類別外的普通函數，但因為被聲明為 friend 函數，仍然能夠訪問 Box 類別的私有成員 width。

Friend 類別允許某一類別訪問另一類別的所有成員。這樣的設置在類別需要緊密協作時非常有用，但使用時應該謹慎，以避免過多暴露內部細節。

範例如下：

#include <iostream>
using namespace std;

class Square;  // 前置聲明

class Rectangle {
private:
    double width, height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    // 聲明 Square 類別為 friend
    friend class Square;
};

class Square {
public:
    double areaOfRectangle(Rectangle &rect) {
        return rect.width * rect.height;
    }
};

int main() {
    Rectangle rect(5.0, 3.0);
    Square square;
    cout << "矩形面積: " << square.areaOfRectangle(rect) << endl;
    return 0;
}
        

在此範例中，Square 類別被宣告為 Rectangle 類別的 friend 類別，因此 Square 類別中的成員函數可以直接訪問 Rectangle 類別的私有成員 width 和 height。

• 數據封裝：允許某些函數或類別進行直接操作，而不破壞類別內部封裝，適合需要高耦合的類別間通信。
• 運算符重載：可以使用 friend 函數來重載運算符，使其能夠訪問類別內部的私有或保護成員。
• 特定訪問需求：在不破壞封裝的前提下，允許外部函數或類別進行有限的訪問，適合庫開發中的特定設計。

在 C++ 中使用 friend 函數和 friend 類別需謹慎，過多使用會破壞類別的封裝性。因此，friend 關鍵字通常只在設計需要密切配合的類別或函數時使用。

C++ 逐行讀取檔案

概述

在 C++ 中，最標準和推薦的逐行讀取文字檔案的方法是使用標準程式庫中的檔案串流類別 std::ifstream 配合 std::getline 函式。

std::ifstream 負責開啟和管理檔案串流，而 std::getline 則負責從串流中讀取一整行文字（直到遇到換行符 \n），並將其儲存到 std::string 物件中。

程式碼範例

以下是一個完整的 C++ 範例，演示如何逐行讀取一個名為 example.txt 的檔案內容。

#include <iostream>
#include <fstream> // 包含檔案串流函式庫
#include <string>  // 包含字串類別

using namespace std; 

void read_file_line_by_line(const string& filename)
{
    // 1. 建立 std::ifstream 物件
    // 嘗試開啟指定的檔案。
    ifstream input_file(filename); 
    
    // 2. 檢查檔案是否成功開啟
    if (!input_file.is_open()) 
    {
        cerr << "錯誤: 無法開啟檔案 " << filename << endl;
        return;
    }
    
    string line;
    int line_number = 1;
    
    // 3. 使用 std::getline 函式進行逐行讀取
    // 循環條件 (getline(stream, string)) 在每次讀取成功時返回 true。
    // 當到達檔案結尾 (EOF) 或發生錯誤時，返回 false，循環結束。
    while (getline(input_file, line)) 
    {
        cout << "第 " << line_number << " 行: " << line << endl;
        line_number++;
    }
    
    // 4. 關閉檔案串流
    // 當 input_file 物件超出其作用域時，析構函式會自動關閉檔案，
    // 但明確呼叫 close() 也是可接受的做法。
    input_file.close(); 
    
    cout << "檔案讀取完成。" << endl;
}

int main()
{
    read_file_line_by_line("example.txt");
    return 0;
}

關鍵概念

• std::ifstream：繼承自 std::istream，專門用於處理檔案輸入串流。在建構時（或使用 open() 函式時）會嘗試開啟檔案。
• input_file.is_open()：這是標準的錯誤檢查。如果檔案不存在或程式沒有讀取權限，這個函式會返回 false。
• std::getline(stream, string)：
  • 它從第一個參數（輸入串流，例如 input_file）中讀取資料。
  • 它將讀到的所有字元（包括空白）儲存到第二個參數（std::string 物件，例如 line）中。
  • 它會讀取並丟棄換行符 \n，因此 line 變數中不包含換行符。
  • 當讀取成功時，它會返回輸入串流物件本身，在條件判斷中會被轉換為 true。
• 自動資源管理： 在 C++ 中，當 std::ifstream 物件 (input_file) 被銷毀時，它會自動呼叫其析構函式來關閉底層的檔案控制代碼，這是一種可靠的資源管理方式（RAII, Resource Acquisition Is Initialization）。

C++ 逐行寫入檔案與欄位對齊

概述

在 C++ 中，要將資料結構（例如從 std::vector<std::string> 中讀取的 tokens）逐行寫入檔案，並確保每個欄位（token）在行中保持固定寬度的對齊，需要使用 **std::ofstream** 配合 **I/O 串流操縱器 (Stream Manipulators)** 來控制輸出格式。

主要的格式控制工具有：

• std::setw(width)：設定下一個輸出欄位的最小寬度。
• std::left / std::right：設定文字在欄位中的對齊方式（靠左或靠右）。

程式碼範例

以下是一個 C++ 範例，示範如何將一個包含多個欄位的二維數據結構（使用 std::vector<std::vector<std::string>> 模擬）寫入檔案，並確保每個 token 欄位的寬度固定為 15 個字元且靠左對齊。

#include <iostream>
#include <fstream> // 包含檔案輸出串流
#include <string>
#include <vector>
#include <iomanip> // 包含 I/O 串流操縱器 (setw, left/right)

using namespace std;

// 模擬一個二維資料結構，每行包含多個欄位 (tokens)
using TableData = vector<vector<string>>;

void write_aligned_data(const string& filename, const TableData& data, int column_width)
{
    // 1. 建立 std::ofstream 物件並開啟檔案
    ofstream output_file(filename); 
    
    // 2. 檢查檔案是否成功開啟
    if (!output_file.is_open()) 
    {
        cerr << "錯誤: 無法開啟檔案 " << filename << " 進行寫入。" << endl;
        return;
    }

    // 設定全域對齊方式：靠左對齊 (L-Justified)
    output_file << left; 
    
    // 3. 逐行寫入資料
    for (const auto& row : data) 
    {
        // 4. 逐 token 寫入並設定寬度
        for (const auto& token : row) 
        {
            // setw(width) 只影響緊隨其後的下一個輸出項
            output_file << setw(column_width) << token;
        }
        
        // 5. 行結束後插入換行符，開始新的一行
        output_file << "\n"; 
    }
    
    // 6. 關閉檔案串流
    output_file.close(); 
    
    cout << "資料已成功寫入檔案: " << filename << endl;
}

int main()
{
    // 範例資料：包含四行，每行三個欄位
    TableData data = {
        {"Name", "Item", "Price"},
        {"Alice", "Book", "19.99"},
        {"BobJohnson", "PenSet", "4.50"},
        {"Charlie", "Notebook", "800.75"}
    };
    
    const int COLUMN_WIDTH = 15; // 定義每個欄位的寬度
    
    write_aligned_data("output_aligned.txt", data, COLUMN_WIDTH);
    
    return 0;
}

關鍵技術解析

• std::ofstream：檔案輸出串流類別。用於將資料寫入檔案。
• #include <iomanip>：此標頭檔必須包含，才能使用 I/O 串流操縱器。
• output_file << left;：
  • 設定對齊模式為左對齊。此設定一旦應用於串流，就會持續有效，直到被 right 或 internal 覆蓋。
• output_file << setw(column_width) << token;：
  • setw(width)：設定接下來要輸出的資料的最小寬度。如果輸出的字串長度小於設定的寬度，則會用空白字元填充。
  • 重要： setw 只對緊隨其後的下一個輸出操作有效，因此必須在每次輸出 token 之前呼叫一次。
• 字元寬度： 請注意，當處理非 ASCII 字元（如中文）時，C++ 標準串流對於多位元組字元集（如 UTF-8）的寬度計算可能不準確。在處理國際化文字時，可能需要更複雜的函式庫來正確計算視覺寬度。上述範例適用於 ASCII 或單一寬度字元。

.NET C++ 讀取 HTML 表格

概述

在 .NET C++ (或更常見的 C++/CLI) 專案中，讀取和解析檔案中的 HTML 表格，通常需要藉助一個外部的 HTML 解析函式庫，因為標準的 .NET 框架和 C++ 本身沒有內建強大的 HTML DOM 解析功能。一個常見且高效的選擇是使用 C# 或其他 .NET 語言的函式庫，然後在 C++/CLI 中引用。

對於 C++/CLI 專案，最實用且推薦的方法是使用 Html Agility Pack (HAP)，這是一個非常流行的 .NET HTML 解析器。雖然 HAP 是用 C# 編寫的，但它可以無縫地在任何 .NET 語言（包括 C++/CLI）中作為參考使用。

使用 Html Agility Pack 的步驟

1. 建立 C++/CLI 專案： 確保您的專案是 C++/CLI 專案（例如：CLR Console Application 或 Windows Forms App）。
2. 獲取 Html Agility Pack：
   • 透過 Visual Studio 的 NuGet 套件管理器，搜尋並安裝 HtmlAgilityPack。
3. 程式碼實作（C++/CLI）：

程式碼範例

以下是一個 C++/CLI 的程式碼片段，演示如何讀取一個本地 HTML 檔案並解析其中的第一個表格 (<table>) 的內容：

#using <System.dll>
#using <System.Xml.dll>
#using <HtmlAgilityPack.dll> // 確保已加入參考

using namespace System;
using namespace System::IO;
using namespace HtmlAgilityPack;

void ParseHtmlTable(String^ filePath)
{
    // 檢查檔案是否存在
    if (!File::Exists(filePath))
    {
        Console::WriteLine("錯誤：檔案不存在。");
        return;
    }

    // 1. 載入 HTML 文件
    HtmlDocument^ doc = gcnew HtmlDocument();
    try
    {
        // 從檔案載入 HTML
        doc->Load(filePath);
    }
    catch (Exception^ ex)
    {
        Console::WriteLine("載入檔案時發生錯誤：" + ex->Message);
        return;
    }

    // 2. 選擇第一個 <table> 節點
    HtmlNode^ table = doc->DocumentNode->SelectSingleNode("//table");

    if (table != nullptr)
    {
        Console::WriteLine("找到 HTML 表格，開始解析...");

        // 3. 選擇所有的 <tr> (表格列) 節點
        HtmlNodeCollection^ rows = table->SelectNodes(".//tr");

        if (rows != nullptr)
        {
            for each (HtmlNode^ row in rows)
            {
                // 4. 選擇 <td> 或 <th> (儲存格) 節點
                // 使用 | 運算子選擇 <td> 或 <th>
                HtmlNodeCollection^ cells = row->SelectNodes("td | th"); 

                if (cells != nullptr)
                {
                    String^ rowData = "";
                    for each (HtmlNode^ cell in cells)
                    {
                        // 獲取儲存格的內部文字並去除首尾空白
                        rowData += cell->InnerText->Trim() + "\t"; 
                    }
                    Console::WriteLine(rowData);
                }
            }
        }
        else
        {
            Console::WriteLine("表格中未找到 <tr> 標籤。");
        }
    }
    else
    {
        Console::WriteLine("檔案中未找到 <table> 標籤。");
    }
}

int main(array<String^>^ args)
{
    // 請將 "your_html_file.html" 替換為您的實際檔案路徑
    String^ htmlFilePath = "C:\\path\\to\\your_html_file.html"; 
    ParseHtmlTable(htmlFilePath);
    return 0;
}

關鍵技術點解釋

• C++/CLI： 允許 C++ 程式碼與 .NET Framework (CLR) 進行互通，這是使用 C# 函式庫 (如 HAP) 的基礎。
• Html Agility Pack： 提供強大的 XPath 支援。
  • doc->Load(filePath)：將本地 HTML 檔案讀取到 HAP 的 DOM 結構中。
  • SelectSingleNode("//table")：使用 XPath 表達式選取文件中的第一個 <table> 元素。
  • SelectNodes(".//tr")：選取當前節點（<table>）下的所有 <tr> 元素。
  • SelectNodes("td | th")：選取 <tr> 節點下的所有 <td> 或 <th> 元素。
  • cell->InnerText：獲取儲存格內容的純文字，會自動去除 HTML 標籤。
• gcnew 和 ^： 這是 C++/CLI 用來建立和管理 .NET 物件（受 CLR 垃圾回收機制管理）的語法。

.NET C++ HTTP API 伺服器

使用 HttpListener 類別

HttpListener 類別允許您在 C++/CLI 應用程式中建立一個簡單的、自託管（Self-Hosted）的 HTTP 伺服器。

專案要求與設定

在 Visual Studio 中建立一個 C++/CLI 專案（例如 CLR Console Application），並確保已引用 System.dll。

程式碼範例

以下是使用 HttpListener 建立一個簡單 API 伺服器並處理 GET 請求的 C++/CLI 程式碼。

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Threading::Tasks;
using namespace System::Text;

// 處理傳入 HTTP 請求的函式
void HandleRequest(HttpListenerContext^ context)
{
    HttpListenerRequest^ request = context->Request;
    HttpListenerResponse^ response = context->Response;

    // 預設回應設定
    response->ContentType = "application/json; charset=utf-8";
    String^ responseString = "";
    response->StatusCode = 200; // 預設為 OK

    // 檢查請求的路徑和方法
    String^ url = request->RawUrl->ToLower();
    
    if (url == "/api/status" && request->HttpMethod == "GET")
    {
        // 處理 GET /api/status 請求
        responseString = "{\"status\": \"Server Running\", \"language\": \"C++/CLI\"}";
    }
    else
    {
        // 處理其他未定義的請求
        response->StatusCode = 404; // Not Found
        responseString = "{\"error\": \"404 Not Found\", \"path\": \"" + url + "\"}";
    }

    // 將字串回應轉換為位元組，並寫入輸出串流
    array<Byte>^ buffer = Encoding::UTF8->GetBytes(responseString);
    response->ContentLength64 = buffer->Length;
    
    try
    {
        response->OutputStream->Write(buffer, 0, buffer->Length);
        response->OutputStream->Close();
    }
    catch (Exception^)
    {
        // 忽略寫入錯誤，通常是客戶端斷開連線
    }
}

// 啟動 HttpListener 的函式
void StartListener(String^ prefix)
{
    HttpListener^ listener = gcnew HttpListener();
    
    try
    {
        listener->Prefixes->Add(prefix);
        listener->Start();
        Console::WriteLine("C++/CLI API Server 啟動，正在監聽: {0}", prefix);
    }
    catch (Exception^ ex)
    {
        Console::WriteLine("啟動 HttpListener 發生錯誤。請確認權限或位址是否已被佔用。");
        Console::WriteLine("錯誤訊息: {0}", ex->Message);
        return;
    }

    // 異步迴圈，持續接收請求
    while (listener->IsListening)
    {
        try
        {
            // 同步等待下一個請求
            HttpListenerContext^ context = listener->GetContext();
            
            // 使用 Task 異步處理請求，避免阻塞監聽迴圈
            Task::Factory->StartNew(gcnew Action<HttpListenerContext^>(&HandleRequest), context);
        }
        catch (Exception^)
        {
            // 監聽器停止時會拋出例外
            break;
        }
    }
    
    if (listener->IsListening)
    {
        listener->Close();
    }
}

int main(array<String^>^ args)
{
    // 設定監聽的 URL 前綴
    // 注意：在 Windows 中，可能需要管理員權限或使用 netsh 註冊 URL 命名空間。
    String^ listeningPrefix = "http://localhost:8080/"; 
    StartListener(listeningPrefix);
    
    Console::WriteLine("按下任意鍵結束伺服器...");
    Console::ReadKey(true);
    
    return 0;
}

執行權限注意

在 Windows 系統中，如果程式碼沒有以管理員權限運行，HttpListener 監聽特定埠時可能會拋出存取拒絕的例外。您可以透過以下命令註冊 URL 命名空間，以允許非管理員帳戶運行伺服器：

netsh http add urlacl url=http://+:8080/ user=Everyone

其中 http://+:8080/ 應替換為您程式碼中實際使用的前綴。

ASP.NET Core C# HTTP API 伺服器

概述

在 ASP.NET Core 中，建立 HTTP API 伺服器的標準專案類型是 Web API。最新的 .NET 版本（.NET 6 及更高版本）推薦使用 Minimal APIs 來快速且輕量地建立 API 端點。

Minimal APIs 使用最少的檔案和程式碼行，將啟動邏輯 (Startup) 和路由定義 (Routing) 合併到一個檔案 Program.cs 中。

專案設定 (使用 CLI)

要建立一個新的 Minimal API 專案，您可以使用 .NET CLI (命令列介面)：

dotnet new web -n MinimalApiServer
cd MinimalApiServer

程式碼範例：Program.cs

以下是 Minimal API 伺服器核心檔案 Program.cs 的完整內容。它定義了伺服器的啟動、中介軟體和兩個 API 端點 (一個 GET，一個 POST)。

// 1. 建立 WebApplication 實例 (取代了傳統的 Startup 類別)
var builder = WebApplication.CreateBuilder(args);

// 2. 註冊服務 (Service Configuration)
// 這裡可以加入資料庫連線、驗證服務等
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(); // 啟用 Swagger/OpenAPI 支援

var app = builder.Build();

// 3. 配置 HTTP 請求管線 (Middleware Configuration)

// 開發環境下，啟用 Swagger UI 以供測試
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

// 啟用 HTTPS 重新導向 (生產環境推薦)
// app.UseHttpsRedirection(); 

// 4. 定義 API 端點 (Endpoint Definition)
// 實體類別用於 POST 請求
public record Product(int Id, string Name, decimal Price);

// GET 請求端點：/api/hello
app.MapGet("/api/hello", () => 
{
    return Results.Ok(new { message = "Hello from ASP.NET Core Minimal API!", timestamp = DateTime.Now });
});

// GET 請求端點：/api/products/{id}
app.MapGet("/api/products/{id}", (int id) => 
{
    // 假設從資料庫查詢產品
    if (id == 1)
    {
        return Results.Ok(new Product(1, "筆記型電腦", 1200.00m));
    }
    return Results.NotFound(new { error = $"Product ID {id} not found" });
});

// POST 請求端點：/api/products
app.MapPost("/api/products", (Product product) => 
{
    // ASP.NET Core 會自動將 JSON 請求主體解序列化為 Product 實體
    Console.WriteLine($"收到新產品: {product.Name} (ID: {product.Id})");
    
    // 實際應用中，這裡會執行資料庫新增操作
    // 回傳 201 Created 狀態碼
    return Results.Created($"/api/products/{product.Id}", product);
});

// 5. 啟動應用程式，開始監聽 HTTP 請求
app.Run();

執行與測試

1. 運行伺服器： 在專案目錄下執行 dotnet run。
2. 測試端點： 伺服器通常預設在 http://localhost:5000 或 https://localhost:7000 運行。
   • 使用瀏覽器或工具 (如 Postman) 訪問 /api/hello (GET)。
   • 訪問 /swagger 路徑可以查看 Swagger UI，用於測試所有定義的 API 端點。

關鍵技術點

• WebApplication.CreateBuilder(args)： 這是 ASP.NET Core 啟動的起點。它建立了 Host 和 Builder，用於配置應用程式的服務和中介軟體。
• app.Services.AddSwaggerGen()： 註冊服務以支援 Swagger/OpenAPI 文件，極大地簡化了 API 的測試與文件生成。
• Middleware (中介軟體)： app.UseSwagger()、app.UseHttpsRedirection() 等，這些組件按順序構成請求處理管線。每個請求都會流經這些中介軟體。
• app.MapGet / app.MapPost： 這是 Minimal APIs 中用於定義路由和處理邏輯的核心方法。它們將 HTTP 動詞與特定的 URL 路徑和 Lambda 處理器函式綁定。
• 自動模型綁定： 在 app.MapPost 範例中，當用戶端發送 JSON 數據時，ASP.NET Core 會自動將其轉換（解序列化）為 C# 的 Product 記錄 (Record)。

週邊控制程式開發

定義

週邊控制程式是用來與電腦或主機連接的外部硬體裝置（例如：印表機、掃描器、馬達、PLC、感測器等）進行通訊與操作的應用程式。

常見通訊介面

• USB
• Serial（RS-232 / RS-485）
• Bluetooth
• Wi-Fi / TCP Socket
• I2C / SPI（多用於嵌入式）

常見開發語言與環境

範例一：使用 Python 控制串列埠

import serial

ser = serial.Serial('COM3', 9600, timeout=1)
ser.write(b'ON\n')  # 傳送控制命令
response = ser.readline()
print("裝置回應：", response.decode())
ser.close()

範例二：C# 控制 COM Port 裝置

SerialPort port = new SerialPort("COM4", 9600);
port.Open();
port.WriteLine("MOVE 100");
string response = port.ReadLine();
Console.WriteLine("回應：" + response);
port.Close();

範例三：控制 USB HID 裝置

• 可用 libusb（C）、pyusb（Python）、HidSharp（C#）等函式庫
• 需掌握 USB Protocol 與裝置 Descriptor 結構

範例四：TCP 通訊控制週邊

import socket

s = socket.socket()
s.connect(('192.168.1.100', 5000))
s.sendall(b'START\n')
data = s.recv(1024)
print("回應:", data.decode())
s.close()

應用案例

• PLC 自動化設備控制
• 3D 印表機 / 雷射雕刻機
• 生產線掃碼器、感測器收集
• POS 系統週邊整合（發票機、條碼機）

注意事項

• 需瞭解裝置的通訊協定（Protocol）與命令格式
• 有些裝置需驅動程式或 SDK 才能通訊
• 通訊延遲、同步處理與錯誤偵測要妥善設計

結論

週邊控制程式開發需依據裝置的介面與協定選擇適合的語言與函式庫，結合串列、USB、網路等通訊方式，可廣泛應用於各種自動化與工控領域。

Barcode Reader 程式開發

常見平台支援

• Android / iOS
• Windows 桌面應用程式
• Web 前端（HTML5 + JavaScript）
• 嵌入式裝置（如樹莓派）

常用條碼類型

• 1D 條碼：EAN-13, Code 39, Code 128, UPC
• 2D 條碼：QR Code, Data Matrix, PDF417

常見開發套件與工具

• ZXing（Java、Android、C++、JavaScript）
• ZBar（C / Python / Linux / Android）
• Dynamsoft Barcode Reader SDK（商用，支援多語言）
• ML Kit Barcode Scanning（Android / Firebase）
• jsQR、QuaggaJS（Web 應用）

Android 開發範例（使用 ZXing）

// build.gradle
implementation 'com.journeyapps:zxing-android-embedded:4.3.0'

// Java 呼叫掃描畫面
IntentIntegrator integrator = new IntentIntegrator(this);
integrator.setPrompt("請掃描條碼");
integrator.setBeepEnabled(true);
integrator.setOrientationLocked(false);
integrator.initiateScan();

// onActivityResult 接收結果
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    IntentResult result = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
    if(result != null) {
        if(result.getContents() != null) {
            String barcode = result.getContents();
            Log.d("條碼內容", barcode);
        }
    }
}

Web 開發範例（使用 QuaggaJS）

<script src="https://unpkg.com/[email protected]/dist/quagga.min.js"></script>

<script>
Quagga.init({
    inputStream: {
        name: "Live",
        type: "LiveStream",
        target: document.querySelector('#scanner')
    },
    decoder: {
        readers: ["code_128_reader", "ean_reader", "upc_reader"]
    }
}, function(err) {
    if (!err) {
        Quagga.start();
    }
});

Quagga.onDetected(function(result) {
    console.log("條碼內容: ", result.codeResult.code);
});
</script>

平台與套件比較

結論

開發 Barcode Reader 可根據平台選擇合適的開源套件，ZXing 是最廣泛支援的選擇，Web 可用 QuaggaJS，若需商業級支援則可考慮 Dynamsoft Barcode SDK。

條碼帶控制字元

基本原理

條碼讀取器本質上是模擬鍵盤輸入的裝置。當掃描到條碼時，它會將條碼中的內容「輸出」成字元流，就像是鍵盤輸入一樣。

因此，條碼中是可以包含控制碼（Control Code），但需要條碼讀取器與條碼格式支援才行。

條碼中常見的控制碼類型

• Ctrl+A ~ Ctrl+Z（ASCII 0x01 ~ 0x1A）
• Enter（CR，ASCII 0x0D）
• Tab（ASCII 0x09）
• ESC（ASCII 0x1B）

條件一：條碼格式需支援控制碼

例如以下格式可編碼控制碼：

• Code 128：支援完整 ASCII 128 字元（包含 Ctrl 字元）
• QR Code：支援所有 Unicode / Binary 資料

條件二：條碼編碼工具需支援嵌入控制碼

部分條碼產生器允許嵌入特殊字元，例如：

• \x0D 表示 Enter
• \x03 表示 Ctrl-C
• ^C、[CTRL+C] 等特殊語法依工具而定

條件三：條碼掃描器需支援輸出控制碼

多數專業條碼機（例如 Zebra、Honeywell）在出廠時預設不啟用控制碼輸出，需透過掃描器提供的「設定條碼」啟用：

• Enable control character transmission
• Enable function key emulation
• Interpret Code 128 FNC1 as ASCII

條件四：作業系統與應用程式需正確接收

例如在 Windows 應用程式中：

• 若條碼輸出 Ctrl+O，應用程式需支援 keydown 與 Ctrl 配合的快捷鍵處理。
• 若條碼輸出的是特殊組合鍵（如 Alt-C），大多應用程式需從低階輸入 API 處理。

示例：編碼 Ctrl-C 的條碼內容

用 Code128 編碼 ASCII 3：

輸入：\x03Hello World

條碼掃描後會觸發 Ctrl+C 再輸出 "Hello World"。

結論

• 條碼可以帶控制碼（如 Ctrl、Alt），但需滿足條件：
• 條碼格式（如 Code128）支援
• 產生器正確編碼
• 掃描器正確設定
• 應用程式能正確接收

Android 開發

Android 開發平台

平台簡介

開發工具

應用程式生命週期

優勢

學習資源

結語

Chromebook 使用 Android Studio

安裝步驟

1. 開啟 設定 → 開發人員 → Linux 開發環境（Crostini），分配至少 20GB 磁碟空間與 8GB 記憶體。
2. 更新套件：

   sudo apt update && sudo apt upgrade -y
   sudo apt install -y wget curl unzip zip git ca-certificates

3. 安裝 JDK（建議版本 17）：

   sudo apt install -y openjdk-17-jdk

4. 下載並安裝 Android Studio：

   sudo dpkg -i ~/Downloads/android-studio-*.deb || sudo apt -f install -y
   android-studio

   或解壓縮 .tar.gz：

   tar -xzf ~/Downloads/android-studio-*.tar.gz -C ~
   ~/android-studio/bin/studio.sh

5. 依照安裝精靈完成 SDK 與工具設定。

使用實體裝置測試

1. 在 ChromeOS：設定 → 開發人員 → Linux → USB 裝置，勾選手機共享給 Linux。
2. 手機開啟 開發人員選項 → USB 偵錯，連線後允許 RSA 指紋。
3. Linux 環境確認裝置：

   sudo apt install -y android-sdk-platform-tools
   adb kill-server
   adb start-server
   adb devices

效能與模擬器建議

• 大部分 Chromebook 模擬器效能不足，建議優先使用實體手機。
• 若必須使用模擬器，選擇 x86_64 版本並降低解析度與 RAM 配置。
• 避免同時執行過多應用程式，確保 Crostini 容器有足夠資源。

替代方案

• VS Code + Android SDK：較輕量，適合 Flutter / React Native 開發。
• 雲端開發環境：如 GitHub Codespaces、Gitpod，降低本機負擔。

Chromebook 使用 VS Code + Android SDK

安裝 VS Code

1. 在 ChromeOS 開啟 設定 → 開發人員 → Linux 開發環境（Crostini）。
2. 下載 VS Code Linux 版（.deb 檔），並於 Linux 容器安裝：

   sudo dpkg -i ~/Downloads/code_*.deb || sudo apt -f install -y

3. 啟動 VS Code，安裝常用擴充套件（如 Kotlin、Flutter、Java Extension Pack）。

安裝 Android SDK 與工具

1. 安裝必要套件：

   sudo apt update && sudo apt install -y openjdk-17-jdk unzip git

2. 下載 Android SDK Command Line Tools：

   wget https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
   unzip commandlinetools-linux-*_latest.zip -d ~/android-sdk

3. 設定環境變數（可加入 ~/.bashrc 或 ~/.zshrc）：

   export ANDROID_SDK_ROOT=$HOME/android-sdk
   export PATH=$ANDROID_SDK_ROOT/cmdline-tools/bin:$ANDROID_SDK_ROOT/platform-tools:$PATH

4. 使用 sdkmanager 安裝平台工具與必要套件：

   sdkmanager "platform-tools" "platforms;android-34" "build-tools;34.0.0"

連接實體手機測試

1. 在 ChromeOS：設定 → 開發人員 → Linux → USB 裝置，勾選手機共享。
2. 手機開啟 開發人員選項 → USB 偵錯。
3. Linux 容器確認裝置：

   adb devices

   看到 device 即可部署測試。

在 VS Code 中開發

• 建立 Kotlin / Java 專案，或使用 Flutter / React Native 框架。
• 在 VS Code 中安裝對應擴充套件，支援語法高亮與除錯。
• 以 adb install 或框架 CLI（如 flutter run）將 App 部署至手機。

適合情境

• Chromebook 硬體資源有限，不適合跑 Android Studio。
• 需要輕量級 IDE，並透過實體手機測試。
• 跨平台開發（Flutter、React Native）效率更高。

Android App 範例

建立新專案

在 Android Studio 中建立一個新的專案，選擇 "Empty Activity" 模板，然後設定專案名稱及其他基本資訊。

編寫介面 (activity_main.xml)

在 res/layout/activity_main.xml 檔案中設計簡單的使用者介面，例如包含一個按鈕和一個文字顯示區域：

        <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:orientation="vertical"
            android:gravity="center">
        
            <Button
                android:id="@+id/button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="點我" />
        
            <TextView
                android:id="@+id/textView"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="Hello, World!"
                android:layout_marginTop="20dp" />
        
        </LinearLayout>

編寫程式邏輯 (MainActivity.java)

在 MainActivity.java 中，設定按鈕的點擊事件，使其更改文字顯示區域的內容：

        package com.example.simpleapp;

        import android.os.Bundle;
        import android.view.View;
        import android.widget.Button;
        import android.widget.TextView;
        import androidx.appcompat.app.AppCompatActivity;

        public class MainActivity extends AppCompatActivity {
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);

                Button button = findViewById(R.id.button);
                TextView textView = findViewById(R.id.textView);

                button.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        textView.setText("你點了按鈕！");
                    }
                });
            }
        }
    

執行應用程式

在 Android Studio 中點擊執行按鈕，即可在模擬器或連接的實體裝置上測試應用程式。點擊按鈕後，文字將更改為 "你點了按鈕！"。

Android 取得目前GPS位置

權限設定

在 AndroidManifest.xml 中加入以下權限：

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

檢查與請求權限（Android 6.0 以上）

if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
    != PackageManager.PERMISSION_GRANTED) {
    ActivityCompat.requestPermissions(this,
        new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 1);
}

取得 LocationManager

LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

取得目前位置

LocationListener locationListener = new LocationListener() {
    @Override
    public void onLocationChanged(@NonNull Location location) {
        double latitude = location.getLatitude();
        double longitude = location.getLongitude();
        Log.d("GPS", "Latitude: " + latitude + ", Longitude: " + longitude);
    }
};

if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
    == PackageManager.PERMISSION_GRANTED) {
    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 
        1000, // 毫秒間隔
        1,    // 最小距離(公尺)
        locationListener);
}

使用 FusedLocationProviderClient（推薦）

FusedLocationProviderClient fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);

if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
    == PackageManager.PERMISSION_GRANTED) {
    fusedLocationClient.getLastLocation()
        .addOnSuccessListener(this, location -> {
            if (location != null) {
                double lat = location.getLatitude();
                double lng = location.getLongitude();
                Log.d("GPS", "Lat: " + lat + ", Lng: " + lng);
            }
        });
}

音控 Android App

基本概念

要實作一個類似 Siri 或 Hey Google 的語音助理功能，你需要結合以下元件：

• 語音辨識（Speech Recognition）
• 語音喚醒（Voice Trigger，可選）
• 語音合成（Text To Speech, TTS）
• 背景服務（Foreground Service）

加入必要權限

<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.INTERNET"/>

語音辨識初始化

SpeechRecognizer recognizer = SpeechRecognizer.createSpeechRecognizer(this);
Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());

recognizer.setRecognitionListener(new RecognitionListener() {
    @Override
    public void onResults(Bundle results) {
        ArrayList<String> matches = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
        if (matches != null && !matches.isEmpty()) {
            String command = matches.get(0).toLowerCase();
            if (command.contains("打開相機")) {
                // 執行操作
            }
        }
    }
    // 其他必要的覆寫方法略
});

recognizer.startListening(intent);

語音合成（回應用戶）

TextToSpeech tts = new TextToSpeech(this, status -> {
    if (status == TextToSpeech.SUCCESS) {
        tts.setLanguage(Locale.TAIWAN);
        tts.speak("你好，我在這裡。", TextToSpeech.QUEUE_FLUSH, null, null);
    }
});

常駐背景監聽（選擇性）

如需常駐背景並語音喚醒，需使用：

• 前景服務（Foreground Service）
• 第三方喚醒庫，例如 Snowboy（已停用）、Porcupine（Picovoice）

注意事項

• SpeechRecognizer 無法在背景連續監聽。
• 建議搭配 Hotword Engine 或使用外部語音 SDK。
• 從 Android 10 起需動態請求 RECORD_AUDIO 權限。

常駐背景監聽

目的

常駐背景監聽的目標，是讓 App 即使在未開啟畫面時也能偵測語音喚醒詞（如「Hey 助理」），並啟動對應功能。

挑戰

• Android 不允許 SpeechRecognizer 長時間背景運行。
• 官方語音辨識 只能短時間收音 並需主動喚起。
• 語音喚醒需使用特殊算法或外部 SDK。

解法架構

1. 使用 前景服務（Foreground Service）保持持續運作。
2. 語音喚醒採用 Porcupine 等離線 Hotword Engine。
3. 喚醒成功後，啟動 SpeechRecognizer 辨識完整語音命令。

Step 1: 前景服務建立

public class VoiceService extends Service {
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Notification notification = new NotificationCompat.Builder(this, "voice_channel")
            .setContentTitle("語音助手運作中")
            .setSmallIcon(R.drawable.ic_mic)
            .build();
        startForeground(1, notification);

        // 初始化 Hotword 檢測
        startHotwordDetection();
        return START_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

Step 2: 建立通知頻道（Android 8+）

NotificationChannel channel = new NotificationChannel("voice_channel",
    "Voice Assistant", NotificationManager.IMPORTANCE_LOW);
NotificationManager manager = getSystemService(NotificationManager.class);
manager.createNotificationChannel(channel);

Step 3: 使用 Porcupine 進行語音喚醒

Porcupine 提供 Android SDK，可辨識自訂關鍵詞並在完全離線情況下運作。

PorcupineManager porcupineManager = new PorcupineManager.Builder()
    .setAccessKey("你的金鑰")
    .setKeywordPath("hey_assistant.ppn")
    .setSensitivity(0.7f)
    .build((keywordIndex) -> {
        // 被喚醒時呼叫 SpeechRecognizer 進行語音辨識
        startSpeechRecognition();
    });

porcupineManager.start();

Step 4: 啟動服務

Intent serviceIntent = new Intent(this, VoiceService.class);
ContextCompat.startForegroundService(this, serviceIntent);

注意事項

• 前景服務在 Android 8 之後是必須的，否則系統會終止 App。
• Porcupine 支援離線運作，但需註冊帳戶取得 AccessKey。
• 記得處理使用者授權 RECORD_AUDIO 權限。

Hey Google 語音助理的優化

使用者端最佳化建議

• 確保語音模型訓練完成：在「Google 助理設定」中進行「Voice Match」訓練，讓裝置更準確辨識個人聲音。
• 避免背景雜音：在安靜環境中使用「Hey Google」效果更佳。
• 裝置靠近嘴部：裝置麥克風收音品質會明顯影響喚醒效果。
• 更新 Google App：最新版本通常會改善語音模型與喚醒靈敏度。
• 開啟「Always on」設定：讓語音喚醒可在螢幕關閉時使用（部分裝置與版本限定）。

開發者端最佳化方式

• 使用 Google Assistant SDK：
  可在嵌入式設備或 Android 上整合原生語音助理體驗。適合 IoT 裝置或特殊應用開發。
  Google Assistant SDK 官方網站
• 啟用 App Actions：
  透過 App Actions 整合 Google Assistant 指令，讓使用者說出語音指令即可打開 App 並執行特定功能。
  例如：「Hey Google，打開我的購物清單」會觸發你的 App 行為。
  App Actions 文件
• Deep Link + Shortcut 提供語意連結：
  讓語音助理能正確觸發應用程式中的特定頁面或操作。

語音喚醒觸發條件優化

• 系統等級喚醒只允許原生 Google 助理使用。
• 非系統助理（第三方 App）無法完全取代「Hey Google」。
• 如需自訂喚醒詞，建議使用 Porcupine、Snowboy（已停用）等工具自建語音助手。

注意限制

• 「Hey Google」語音觸發屬系統級權限，不可由第三方 App 截獲。
• Google 未開放「Hey Google」語音觸發的 SDK 授權。
• Android 11+ 更限制麥克風權限與背景存取。

Apple 產品程式開發

開發工具

• Xcode: Apple 官方的開發環境 (IDE)，支援 macOS、iOS、watchOS 及 tvOS 應用程式開發。
• Swift: Apple 推出的現代化程式語言，安全且高效能。
• SwiftUI: 宣告式 UI 框架，簡化 UI 開發。
• UIKit: 傳統的 UI 框架，提供完整的 UI 控件與自定義功能。

開發環境設定

1. 下載並安裝最新版本的 Xcode。

2. 開啟 Xcode 並前往 Preferences > Accounts，登入 Apple ID 以啟用開發者功能。

3. 透過 Xcode 安裝 Command Line Tools 以使用 Swift 命令列工具。

開發平台

• iOS: 開發 iPhone 與 iPad 應用程式。
• macOS: 開發桌面應用程式。
• watchOS: 為 Apple Watch 開發應用程式。
• tvOS: 開發 Apple TV 應用程式。

建立專案

1. 開啟 Xcode，選擇「Create a new Xcode project」。

2. 選擇適合的應用程式模板，例如 App (iOS/macOS)。

3. 設定專案名稱、識別碼 (Bundle Identifier) 及語言 (Swift 或 Objective-C)。

4. 選擇 UI 框架 (SwiftUI 或 UIKit)。

模擬與測試

• 使用 iOS Simulator 在不同裝置上測試應用程式。
• 透過 TestFlight 發布 Beta 測試版本給測試人員。
• 使用 XCTest 進行單元測試與 UI 測試。

應用程式發布

1. 註冊 Apple Developer Program (需年費 USD $99)。

2. 透過 Xcode 設定 App Store Connect 並提交 App。

3. 遵循 Apple 的 App Store Review Guidelines 確保應用程式符合上架規範。

iOS開發

開發工具

iOS 開發主要使用 Xcode，這是 Apple 提供的官方整合開發環境 (IDE)。

• 程式語言：Swift 和 Objective-C
• 支援模擬器進行測試
• 提供 Interface Builder 設計視覺化介面

開發流程

1. 設計應用程式架構與介面
2. 編寫程式碼實現功能
3. 使用模擬器或實機進行測試
4. 進行錯誤排除與性能優化
5. 通過 App Store 提交與發佈

必備知識

學習 iOS 開發需要掌握以下基礎：

• Swift 語法與基礎
• UIKit 或 SwiftUI 的使用
• 基本設計模式，例如 MVC、MVVM
• 處理網路請求與 JSON
• 應用程式生命周期與背景運作

開發資源

以下是一些實用的學習與開發資源：

• Apple 開發者官網
• Swift 官方網站
• Ray Wenderlich 教學網站
• Stack Overflow 技術社群

Xcode

功能特色

Xcode 是 Apple 提供的整合開發環境 (IDE)，用於 macOS、iOS、watchOS 和 tvOS 應用程式的開發。

• 支援 Swift 和 Objective-C 語言
• 內建模擬器可測試多種設備與系統版本
• 提供 Interface Builder 設計視覺化介面
• 整合 Git 版本控制
• 強大的編譯器與除錯工具

主要組件

1. Code Editor： 提供語法高亮、代碼補全與錯誤提示功能
2. Interface Builder： 支援直覺式拖放設計介面
3. Simulator： 用於測試與模擬應用程式在不同裝置上的運行
4. Debugging 工具： 支援斷點、記憶體檢測與性能分析

安裝與更新

可從 Mac App Store 或 Apple 開發者官網下載最新版本的 Xcode。

• 系統需求：macOS 最新版本
• 定期更新以獲取最新功能與錯誤修正

使用技巧

提升開發效率的實用技巧：

• 利用快捷鍵快速切換檔案與視圖
• 配置自定義模版以重複使用代碼
• 啟用靜態分析工具檢查潛在問題
• 學習如何使用 LLDB 命令進行高效除錯

資源

相關學習與參考資源：

• Xcode 官方網站
• Apple 開發者文檔
• Ray Wenderlich 教學網站

Swift

語言特點

Swift 是 Apple 推出的現代化程式語言，用於開發 iOS、macOS、watchOS 和 tvOS 應用程式。

• 快速且高效的性能
• 簡潔易讀的語法
• 支援安全性檢查，例如可選型別避免空指針錯誤
• 支援函式式編程與物件導向編程
• 強大的錯誤處理機制

語法基礎

• 變數與常數： 使用 var 和 let
• 可選型別： 使用 ? 和 ! 處理值的存在與否
• 控制流程： 包括 if、switch、for、while
• 函數： 使用 func 定義，支援參數標籤與多返回值
• 類別與結構： 使用 class 和 struct

核心概念

1. 使用 Protocol 實現介面與協議
2. 利用 Extension 擴展類別功能
3. 泛型支援提升代碼重用性
4. 運用閉包 (Closures) 實現高階函數
5. 支援自定義操作符與元組

應用場景

Swift 不僅適用於 Apple 生態系統，還可以用於伺服器端開發與跨平台工具。

• iOS 和 macOS 應用程式開發
• 伺服器端應用程式使用 Swift on Server
• 學術研究與快速原型開發

資源

相關學習與參考資源：

• Swift 官方網站
• Apple Swift 開發者資源
• Hacking with Swift 教學網站
• Stack Overflow 技術社群

Objective-C

特點

Objective-C 是一種以 C 為基礎的物件導向程式語言，最初由 NeXT 公司開發，後來被 Apple 廣泛用於 macOS 和 iOS 應用程式開發。

• 基於 C 語言，具備高效能與靈活性
• 支援動態運行時 (Runtime)
• 使用 Smalltalk 風格的訊息傳遞

語法結構

Objective-C 的語法結合了 C 和 Smalltalk 的特性，使用 @ 符號來標示語言擴展。

• 類定義： 使用 @interface 和 @implementation
• 訊息傳遞： 使用方括號語法 [object method]
• 屬性： 使用 @property 和 @synthesize

核心概念

1. 物件導向程式設計，包括類別與繼承
2. 協議 (Protocols) 用於定義方法集合
3. 分類 (Categories) 用於擴展類別功能
4. Block 語法用於閉包與回呼

開發工具

Objective-C 的開發主要使用 Apple 的 Xcode。

• 提供編輯、編譯與除錯功能
• 整合 Interface Builder 設計視覺化介面
• 支援 iOS 與 macOS 應用程式開發

資源

以下是一些學習與參考的資源：

• Apple 官方文檔
• objc.io 技術博客
• Stack Overflow 技術社群
• GitHub 儲存與分享代碼

GNews

什麼是GNews？

GNews是一個由Google開發的新聞聚合平台，旨在幫助用戶獲取最新的全球新聞資訊。它整合了來自各種新聞來源的內容，使用人工智慧技術來個性化推薦用戶感興趣的新聞。

GNews的主要功能

• 新聞聚合：GNews會從各大新聞網站、博客和社交媒體收集最新的新聞報導，提供多元化的新聞來源。
• 個性化推薦：根據用戶的閱讀習慣和興趣，GNews會智能推薦相關的新聞內容，使用戶能快速找到感興趣的話題。
• 實時更新：平台會持續更新新聞資訊，使用戶隨時能獲取最新的國內外新聞動態。
• 多語言支持：GNews支持多種語言，方便不同地區的用戶獲取新聞資訊。

如何使用GNews？

用戶可以通過訪問GNews的網站或下載其應用程式來使用此平台。在平台上，用戶可以選擇感興趣的主題、追蹤特定的新聞來源，並根據自己的需求自訂新聞推送。

GNews的優勢

• 便捷性：用戶不需要逐一訪問各新聞網站，GNews將所有相關資訊集中在一個平台上。
• 快速獲取資訊：實時更新的功能讓用戶能夠快速獲得最新的新聞動態，無論是政治、經濟、科技還是娛樂新聞。
• 多元化的新聞來源：GNews整合了來自不同來源的新聞，使用戶能夠獲得更全面的資訊。

結論

GNews是一個強大的新聞聚合工具，透過人工智慧技術，為用戶提供個性化的新聞體驗。隨著新聞資訊的快速變化，GNews幫助用戶快速跟上世界動態，獲取所需的資訊。

自動化流程工具

AI開發程式

Bolt

Bolt 是一個快速、輕量的 AI 開發框架，專注於提供開發者簡單且高效的工具來建構應用程式。特點包括：

• 快速啟動：適合新手開發者快速建立原型。
• 模組化設計：可擴展性強，適用於多種應用場景。
• 輕量：佔用資源少，運行高效。

Cursor

Cursor 是專為 AI 程式開發設計的編輯器工具，提供智能輔助程式碼撰寫與調試功能。特點包括：

• 程式碼生成：利用 AI 智能補全與提示。
• 語法錯誤檢查：減少開發錯誤率。
• 內建版本控制：提升團隊協作效率。

v0

v0 是一個基於視覺化開發的 AI 平台，允許使用者透過拖放介面構建模型與應用。特點包括：

• 無需程式碼：適合無技術背景的開發者。
• 直觀介面：以視覺化方式操作，學習曲線低。
• 即時預覽：快速測試模型效果。

Codeium

Codeium 是一款結合 AI 智能輔助的程式編輯器，專注於提升程式開發效率與準確性。特點包括：

• 智能補全：根據上下文生成高品質程式碼。
• 多語言支援：適用於多種程式語言的開發需求。
• 整合環境：可與多種 IDE 相容，無縫整合。

軟體工程

定義

軟體工程是一門系統性、規劃性地開發、操作與維護軟體的工程學科，目標是建構高品質、可維護、可靠且符合需求的軟體系統。

核心目標

• 提高軟體品質
• 降低開發成本
• 縮短開發時程
• 增強維護與擴充性

軟體開發生命週期（SDLC）

1. 需求分析：蒐集與分析使用者需求，製作需求規格書
2. 系統設計：設計系統架構、模組、資料庫與介面
3. 實作：依據設計撰寫程式碼
4. 測試：進行單元測試、整合測試、系統測試與驗收測試
5. 部署與上線：將系統部署至生產環境
6. 維護與更新：修正錯誤、更新功能、優化效能

常見開發方法論

• 瀑布式（Waterfall）：階段性完成、流程明確、變更成本高
• 敏捷式（Agile）：迭代開發、快速回饋、強調團隊合作
• Scrum：一種敏捷方法，分為短衝（Sprint）、日會、回顧等儀式
• DevOps：整合開發與運維，強調自動化與持續交付

常見工具與技術

• 版本控制：Git、GitHub、GitLab
• 專案管理：Jira、Trello、Asana
• CI/CD：Jenkins、GitHub Actions、GitLab CI
• 測試工具：JUnit、Selenium、Postman

品質屬性

• 可用性（Availability）
• 可維護性（Maintainability）
• 可擴充性（Scalability）
• 安全性（Security）
• 效率（Efficiency）

角色分工

• 系統分析師：負責需求訪談與分析
• 軟體設計師：設計系統架構與模組
• 程式設計師：負責撰寫與測試程式
• 測試工程師：執行測試並回報缺陷
• 專案經理：規劃時程、協調團隊

敏捷開發

核心價值

• 個人與互動勝於流程與工具
• 可工作的軟體勝於詳盡的文檔
• 客戶合作勝於合約談判
• 應對變化勝於遵循計劃

主要原則

1. 以最高優先級滿足客戶需求，通過早期且持續的交付提供價值。
2. 歡迎需求變更，即使在開發後期，也能利用變更為客戶創造競爭優勢。
3. 頻繁交付可工作的軟體，交付周期通常以數周或數月計算。
4. 開發與業務團隊應該每天合作，促進溝通與理解。
5. 以有動機的個人為核心，提供支持並信任他們完成工作。
6. 面對面交流是最有效的溝通方式。
7. 衡量進度的主要指標是可工作的軟體。
8. 提倡可持續的開發節奏，所有參與者應能維持穩定的步調。
9. 追求技術卓越與設計簡潔，提升靈活性與質量。
10. 保持簡單，專注於完成必要的工作。
11. 自組織團隊能產生最佳設計與架構。
12. 定期反思並調整行為以提升效率。

常用框架

• Scrum：強調短衝刺與固定節奏的開發。
• Kanban：專注於持續流動與可視化工作。
• Extreme Programming (XP)：注重技術實踐與高頻率交付。
• Lean：關注減少浪費並提高價值流效率。

適用場景

• 需求變化頻繁的專案。
• 需要快速交付最小可行產品 (MVP) 的情況。
• 開發過程需要密切客戶參與。
• 跨職能團隊協作的專案。

軟體開發需求文件範本

專案名稱

請填入本專案的正式名稱。

版本紀錄

• 版本：1.0
• 撰寫日期：YYYY-MM-DD
• 撰寫人：姓名
• 審核人：姓名

專案背景與目標

說明此專案的緣由、背景問題以及欲解決的核心問題，並定義明確的專案目標。

系統概要

概述系統功能與整體架構，可搭配系統架構圖。

功能需求

• 功能編號：例如：F-001
• 功能名稱：用戶註冊
• 功能描述：使用者可透過電子郵件與密碼進行註冊。
• 前置條件：未註冊帳號的使用者
• 輸入：電子郵件、密碼
• 處理：驗證格式並儲存於資料庫
• 輸出：註冊成功訊息或錯誤提示

非功能性需求

• 系統應具有99.9%的可用性
• 支援每秒至少100個並發請求
• 回應時間小於2秒
• 支援HTTPS加密

使用者角色與權限

• 一般使用者：註冊、登入、使用基本功能
• 管理員：使用者管理、系統設定

畫面與介面需求

可附上主要畫面草圖或線框圖，描述各畫面的元素與互動流程。

資料需求

列出主要資料表結構、欄位、關聯性等。

整合與相依性

列出需整合的外部系統、API或其他軟體元件。

時程與里程碑

• 需求確認：YYYY-MM-DD
• 初版開發完成：YYYY-MM-DD
• 測試完成：YYYY-MM-DD
• 上線時間：YYYY-MM-DD

風險與限制

列出潛在風險、限制條件（如預算、人力、技術等）。

附錄

相關文件連結、參考資料、名詞定義等。

設計模式

定義

設計模式（Design Patterns）是一組經過實踐驗證的軟體設計解決方案，主要應用於物件導向程式設計中，用來解決在特定情境下反覆出現的設計問題。

三大類別

• 建立型：（Creational）專注於如何建立物件
• 結構型：（Structural）關注類別與物件的組合方式
• 行為型：（Behavioral）處理物件之間的互動與職責分配

常見建立型模式

• 單例模式：（Singleton）確保一個類別在系統中只會有一個實例
• 工廠方法：（Factory Method）使用子類別來決定建立哪個物件
• 抽象工廠：（Abstract Factory）提供建立一組相關物件的介面
• 建造者模式：（Builder）將物件的建立過程與表示分離
• 原型模式：（Prototype）透過複製現有實例來建立新物件

常見結構型模式

• 適配器模式：（Adapter）將一種介面轉換為用戶所期望的另一種介面
• 裝飾者模式：（Decorator）在不修改原類別的情況下，動態新增功能
• 外觀模式：（Facade）提供一個統一的介面來存取複雜子系統
• 組合模式：（Composite）將物件組合成樹狀結構以表示整體/部分層次
• 代理模式：（Proxy）提供控制對目標物件存取的機制

常見行為型模式

• 觀察者模式：（Observer）當某物件改變狀態時，自動通知所有依賴者
• 策略模式：（Strategy）定義一系列演算法，並可在執行時替換
• 命令模式：（Command）將操作封裝為物件，以支援復原、排程等操作
• 狀態模式：（State）允許物件在內部狀態改變時改變其行為
• 迭代器模式：（Iterator）提供一種遍歷集合元素的方法

設計模式的優點

• 提升程式結構的可重用性與可維護性
• 使系統更具彈性與可擴充性
• 加強團隊開發中的溝通與共識

使用建議

• 根據實際需求選擇合適模式，避免過度設計
• 搭配 SOLID 原則可發揮更佳效果
• 在重構時導入設計模式可提升可讀性與穩定性

版本控制

定義

版本控制（Version Control）是一種管理檔案變更歷史的系統，廣泛應用於軟體開發中，讓多位開發者能同時協作，並保留每次變更的完整記錄。

主要功能

• 追蹤每次檔案變動的內容與原因
• 還原到任何歷史版本
• 分支管理以支援多版本並行開發
• 整合多位開發者的修改

版本控制系統類型

• 本地版本控制：紀錄儲存在單一電腦上
• 集中式版本控制：（Centralized VCS）如 SVN，所有開發者透過中央伺服器協作
• 分散式版本控制：（Distributed VCS）如 Git，每位開發者有完整版本庫

常見工具

• Git：最廣泛使用的分散式版本控制系統
• GitHub：Git 的雲端託管平台，支援 Pull Request、Issue、CI/CD 等功能
• GitLab：類似 GitHub，並內建 CI/CD 管理功能
• Bitbucket：支援 Git 與 Mercurial，適合與 Jira 整合

Git 基本指令

• git init：初始化版本庫
• git clone [網址]：複製遠端專案
• git add [檔案]：加入變更至暫存區
• git commit -m "訊息"：提交變更
• git push：將變更推送至遠端儲存庫
• git pull：取得並合併遠端變更
• git branch：查看或建立分支
• git merge：合併分支

分支策略

• Main / Master：穩定可部署版本
• Develop：主要開發分支
• Feature Branch：新功能開發用
• Release Branch：準備發佈版本
• Hotfix Branch：緊急修復生產問題

好處

• 提升團隊協作效率
• 降低版本衝突與風險
• 確保開發流程有跡可循
• 支援快速切換與測試不同版本

Git

簡介

Git 是一種分散式版本控制系統，由 Linus Torvalds（Linux 之父）於 2005 年開發，用於追蹤程式碼變更、協同開發與版本管理。它是現今最廣泛使用的版本控制工具，被應用於個人開發、團隊專案與開源社群中。

核心概念

• Repository（儲存庫）：儲存所有版本歷史與檔案的資料夾，可分為本地端與遠端。
• Commit：一次變更記錄，代表一組檔案的修改狀態。
• Branch（分支）：獨立的開發線路，讓多人可同時開發不同功能而不互相干擾。
• Merge（合併）：將不同分支的變更整合到主分支。
• Clone：將遠端儲存庫複製到本地。
• Push / Pull：上傳或下載變更到遠端儲存庫。

安裝 Git

1. 前往 Git 官方網站 下載適合的版本。
2. 安裝後開啟命令提示字元（CMD）或 PowerShell。
3. 輸入 git --version 以確認安裝成功。

初始設定

第一次使用 Git 時，需設定開發者資訊：

git config --global user.name "你的名稱"
git config --global user.email "你的[email protected]"

基本指令

git init              # 初始化本地儲存庫
git clone URL         # 複製遠端儲存庫
git add .             # 將變更加入暫存區
git commit -m "說明"  # 建立一次提交
git status            # 查看當前狀態
git log               # 查看提交紀錄
git branch            # 查看分支列表
git checkout 分支名   # 切換分支
git merge 分支名      # 合併指定分支
git push              # 將變更推送到遠端
git pull              # 從遠端拉取更新

常見工作流程

1. 建立或複製儲存庫（git init 或 git clone）
2. 編輯或新增檔案
3. 將修改加入暫存區（git add）
4. 提交變更（git commit）
5. 與遠端同步（git push / git pull）

與 Visual Studio 整合

• Visual Studio 內建 Git 支援，可直接操作分支、Commit、Push。
• 可連接 GitHub、Azure DevOps、GitLab 等服務。
• 透過「Git Changes」面板可檢視與管理版本變更。

優點

• 分散式架構，每位開發者都有完整版本歷史。
• 速度快、效率高，支援離線作業。
• 強大的分支與合併功能。
• 跨平台支援（Windows、Linux、macOS）。

常見遠端服務

• GitHub — 全球最大的開源社群平台
• Azure DevOps — 微軟企業級整合平台
• GitLab — 自託管與雲端版本控制服務
• Bitbucket — 支援 Git 與 Mercurial 的專案平台

GitHub

GitHub 是一個基於雲端的版本控制和協作平台，主要用於軟體開發。它使用 Git 進行版本控制，讓開發者能夠管理專案的源代碼、跟蹤變更以及與他人協作。

主要功能

• 版本控制： 透過 Git 跟蹤文件的變更，保留歷史記錄，並能夠回溯到先前的版本。
• 協作工具： 開發者可以通過 pull requests、code reviews 等功能進行協同開發。
• 項目管理： 提供 issues、projects 等功能來追踪任務和計劃。
• GitHub Actions： 支持 CI/CD (持續整合和持續交付) 自動化工作流。

使用 GitHub 的好處

• 集中管理代碼，確保代碼的透明性和可追溯性。
• 提供完善的版本控制工具，方便回退或合併不同版本。
• 開發者之間可以通過平台進行代碼審查，提高代碼質量。
• 支持自動化流程，提升開發效率。

適用對象

GitHub 適合各類開發者，無論是單獨開發者、開源社區還是企業團隊。它能夠滿足小型專案到大型軟體專案的版本控制和協作需求。

GitHub 使用 git pull --rebase

git pull --rebase 是從遠端分支拉取最新變更，並將本地的更改重新應用到最新的遠端提交之上，而不是使用傳統的合併。

使用方式

git pull --rebase

工作流程

1. 從遠端分支獲取最新更改。
2. 暫時移除本地的提交。
3. 將遠端提交應用到本地分支。
4. 重新應用本地的提交，保持歷史記錄線性。

為什麼使用 --rebase？

• 保持線性歷史： --rebase 可以讓提交歷史保持簡潔，沒有多餘的合併提交。
• 避免合併提交： 防止使用傳統合併產生過多的合併記錄。

使用範例

假設你在本地提交了一些更改，而遠端也有新的提交，使用 git pull --rebase 會：

• 下載並應用遠端的最新提交。
• 將你的本地提交重新應用到這些最新的遠端提交之後。

解決衝突

如果在重放本地提交時發生衝突，Git 會要求手動解決衝突：

1. 解決衝突並使用 git add 暫存已解決的文件。
2. 使用 git rebase --continue 繼續重放提交。
3. 若想取消操作，使用 git rebase --abort 回到原狀。

總結

git pull --rebase 是保持 Git 提交歷史整潔的重要工具，特別適合多人協作時，能夠避免產生冗餘的合併提交，並保持代碼庫的提交記錄線性。

Visual Studio 使用 Git

概述

Visual Studio 內建 Git 整合功能，但仍需在系統中安裝 Git 執行檔，才能進行版本控制操作（如 Commit、Push、Pull、Merge 等）。

步驟一：確認是否已安裝 Git

1. 開啟命令提示字元（CMD）或 PowerShell。
2. 輸入以下指令：

   git --version

3. 若顯示類似 git version 2.x.x，代表已安裝；若顯示「無法辨識 git 指令」，則需安裝 Git。

步驟二：下載並安裝 Git

1. 前往 Git 官方下載頁面。
2. 選擇對應的作業系統版本（Windows、macOS 或 Linux）。
3. 下載後執行安裝程式，建議使用預設設定一路按「下一步」。
4. 安裝完成後重新啟動 Visual Studio。

步驟三：設定 Git 使用者資訊

開啟命令提示字元，設定您的使用者名稱與電子郵件：

git config --global user.name "你的名稱"
git config --global user.email "你的[email protected]"

這些資訊會附加在每次提交（commit）中，用於識別開發者身份。

步驟四：在 Visual Studio 啟用 Git

1. 開啟 Visual Studio。
2. 點選上方選單的 視圖 (View) → Team Explorer。
3. 選擇 連線 (Connect) → Clone a repository 以複製遠端儲存庫。
4. 或在現有專案中點擊 Git → 建立 Git 儲存庫，讓專案成為版本控制的一部分。

步驟五：驗證整合狀態

• 在 Visual Studio 的狀態列可看到目前分支名稱。
• 可使用「Git Changes」視窗進行 Commit、Pull、Push 操作。
• 若 Visual Studio 顯示「未偵測到 Git」，請確認 Git 安裝路徑已加入系統環境變數。

補充：使用 Visual Studio 內建 Git 安裝

若使用 Visual Studio 2022 或更新版本，在安裝過程中可勾選 「Git for Windows」 選項。這樣 Visual Studio 會自動安裝與整合 Git，無需手動設定。

完成後效果

設定完成後，您可以直接在 Visual Studio 中完成以下操作：

• 建立分支、提交 (Commit)、推送 (Push) 與合併 (Merge)
• 檢視版本歷史與比較差異
• 與 GitHub、Azure Repos 或其他遠端儲存庫整合

Azure DevOps

平台簡介

Azure DevOps 是由 Microsoft 提供的一套整合式開發與協作平台，支援從程式碼管理、建置、自動化測試到部署的完整 DevOps 流程。它適用於多種程式語言與框架，可用於個人專案或大型企業團隊開發。

主要服務組成

• Azure Repos：提供 Git 或 TFVC 版本控制，支援 Pull Request、分支管理與原始碼審查。
• Azure Boards：用於工作項目追蹤、看板（Kanban）、Scrum 計畫與進度管理。
• Azure Pipelines：支援 CI/CD（持續整合與持續部署），可自動建置、測試並部署應用至多平台。
• Azure Test Plans：提供手動與自動化測試管理工具，確保軟體品質。
• Azure Artifacts：管理套件與依賴庫，可建立私有 NuGet、npm、Maven 等封裝源。

主要特色

• 跨平台支援，可在 Windows、Linux、macOS 上運行。
• 可與 GitHub、Docker、Kubernetes、Jenkins 等整合。
• 提供 REST API 與 YAML-based Pipeline 配置。
• 支援雲端與內部部署（Azure DevOps Server）。

常見用途

• 建立 Git 儲存庫並管理程式碼版本。
• 建立自動化建置流程（CI）。
• 設定自動部署流程（CD），將應用部署至 Azure、AWS 或內部伺服器。
• 透過 Boards 管理產品待辦清單與開發進度。
• 在 Test Plans 中進行品質驗證與測試報告。

使用方式

1. 前往 Azure DevOps 官方網站。
2. 登入或註冊 Microsoft 帳號。
3. 建立新組織（Organization）與專案（Project）。
4. 設定 Repos、Pipelines、Boards 等模組開始開發與部署流程。

優點

• 集中化開發管理平台，整合從規劃到部署的全流程。
• 權限與角色管理清晰，適合大型團隊。
• 彈性高，支援多雲與多語言開發環境。

適用場景

• 企業級專案的 CI/CD 流程管理。
• 跨部門協作與任務追蹤。
• 開源與私有程式碼儲存庫管理。

Azure DevOps 存取層級

步驟說明

1. 登入 Azure DevOps。
2. 在左下角點選 Organization Settings（組織設定）。
3. 在左側選單中選擇 Users（使用者）。
4. 系統會列出組織中所有使用者及其對應的 Access Level（存取層級）。

常見的 Access Level 類型

• Basic：可使用大部分開發功能，例如 Boards、Repos、Pipelines。
• Stakeholder：僅能檢視與參與基本工作項目（免費）。
• Basic + Test Plans：包含 Basic 權限，並可使用測試管理功能。
• Visual Studio Subscriber：若帳號綁定了 Visual Studio 訂閱，會自動擁有相應層級的權限。

進階操作

• 若您是組織管理員，可點選使用者右側的 三點選單（⋯） 修改其層級。
• 若權限不足，請聯繫組織擁有者或系統管理員以提升存取層級。

提示

若您在使用 Azure DevOps Pipelines、Repos 或 Boards 時遇到權限限制問題，請先確認您的 Access Level 是否為 Basic 或以上等級。

程式部署

定義

程式部署（Application Deployment）是將開發完成的應用程式從開發環境移轉至測試或生產環境，讓使用者可以實際使用的過程。它確保系統能在不同環境中穩定、可重現地執行。

部署流程

1. 建置（Build）：將原始程式碼編譯、打包成可執行檔或映像檔。
2. 測試（Test）：驗證功能、效能及相容性。
3. 部署（Deploy）：將應用與設定檔部署至伺服器。
4. 監控（Monitor）：持續監控運行狀況、記錄日誌及效能指標。

常見部署方式

• 手動部署：人工上傳檔案、修改設定，適合小型專案。
• 自動化部署：利用工具自動化流程，減少人為錯誤。
• 容器化部署：使用 Docker 等技術封裝應用，使環境一致。
• 雲端部署：將應用部署至 AWS、Azure、Google Cloud 等雲端平台。

常見部署架構

• 單機部署：應用與資料庫皆於同一伺服器上運行。
• 前後端分離：前端（如 React、Vue）與後端（如 Node.js、Python）獨立部署。
• 微服務架構：將應用拆分成多個小型服務，分別獨立部署與管理。
• 叢集部署：利用多台伺服器分散負載與確保高可用性。

自動化部署工具

• Jenkins：持續整合與自動化部署工具。
• GitHub Actions：整合在 GitHub 中的 CI/CD 平台。
• GitLab CI/CD：GitLab 內建的自動化流程管理。
• Ansible：用於自動化伺服器設定與應用部署。
• Docker Compose / Kubernetes：支援容器化應用的部署與管理。

部署範例

# 使用 GitHub Actions 部署範例
name: Deploy Web App
on:
  push:
    branches: [ "main" ]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: 建立 Docker 映像
        run: docker build -t myapp .
      - name: 部署至伺服器
        run: docker run -d -p 80:80 myapp

部署時的考量

• 環境變數與設定檔分離
• 版本控制與回滾機制
• 自動化測試與驗證
• 監控與日誌收集
• 安全性（如 SSL、憑證、權限設定）

部署策略

• 藍綠部署：使用兩套環境（Blue/Green），新版本上線後再切換流量，確保不中斷服務。
• 滾動更新：逐步替換舊版本容器，保持服務連續性。
• 金絲雀部署：先讓少部分用戶使用新版本，觀察穩定後再全面推廣。

最佳實踐

• 將部署流程自動化，確保一致性
• 使用版本控制記錄部署變更
• 建立持續整合與持續交付（CI/CD）管線
• 隨時可回滾至前一版本
• 監控效能與錯誤日誌，持續優化部署流程

容器化技術

定義

Docker（容器技術）是一個開放原始碼的平台，用於自動化應用程式的部署、擴展與管理。它利用「容器」（Container）將應用與其依賴封裝在一起，確保在不同環境中能一致執行。

核心概念

• 映像檔（Image）：一個可執行的環境快照，包含應用程式及其依賴
• 容器（Container）：由映像檔建立的可執行實例，運行於隔離環境中
• Dockerfile：描述如何建構映像檔的設定檔案
• Docker Hub：官方映像檔託管平台，類似於「GitHub for Docker」

Docker 的優點

• 跨平台一致性：確保「開發環境與生產環境一致」
• 輕量快速：比虛擬機器啟動速度快，資源占用少
• 可移植性高：映像檔可在任何支援 Docker 的平台執行
• 便於版本控制與回滾

基本指令

• docker pull [映像名稱]：下載映像檔
• docker run [映像名稱]：執行容器
• docker ps：查看執行中的容器
• docker stop [容器ID]：停止容器
• docker rm [容器ID]：刪除容器
• docker build -t [名稱] .：依據 Dockerfile 建立映像檔
• docker images：查看映像檔清單

Dockerfile 範例

# 使用 Python 映像檔
FROM python:3.10

# 設定工作目錄
WORKDIR /app

# 複製程式檔案
COPY . /app

# 安裝依賴套件
RUN pip install -r requirements.txt

# 指定容器啟動時執行的指令
CMD ["python", "app.py"]

Docker Compose

Docker Compose 是一個可定義多個容器應用的工具，使用 docker-compose.yml 檔案定義各服務。

version: '3'
services:
  web:
    build: .
    ports:
      - "8000:8000"
  db:
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: example

應用場景

• 建立一致的開發與測試環境
• 快速部署微服務架構
• 持續整合與部署（CI/CD）流程
• 多版本應用程式的隔離運行

相關技術

• Kubernetes：容器編排與自動化管理平台
• Podman：無需 daemon 的容器工具
• Docker Swarm：Docker 原生的容器叢集管理系統

.NET C++ 程式部署至 Ubuntu

前言

在 Ubuntu 系統上部署 .NET C++（C++/CLI 或以 .NET 為基底的 C++ 應用）需要根據專案類型分別處理。若使用純 C++/CLI（依賴 .NET Framework），將無法直接於 Linux 執行，需改為使用 .NET 6/7/8 的跨平台技術（如 C++/CLR → C# 或使用 C++/Native 搭配 .NET 互通）。

部署方式概述

根據應用性質，部署可分為三種情境：

1. 純 C++ 應用：使用 g++ 編譯，直接於 Ubuntu 執行。
2. .NET Managed C++ (C++/CLI)：需重新設計為 .NET 6 以上版本支援的 C# 或 C++/CLI for Core（僅 Windows 支援）。
3. 混合式應用：C# 為主，C++ 以動態函式庫（.so）提供性能模組。

環境安裝

在 Ubuntu 中安裝 .NET SDK 與必要工具：

sudo apt update
sudo apt install -y dotnet-sdk-8.0
sudo apt install -y build-essential

（可依版本替換 dotnet-sdk-8.0 為 dotnet-sdk-7.0 或其他版本）

建立專案

若使用 .NET C# 為主程式，並呼叫 C++ 函式庫：

# 建立主應用
dotnet new console -n MyApp
cd MyApp

# 建立 native 函式庫
mkdir native
cd native
nano add.cpp

add.cpp 範例：

extern "C" int add(int a, int b) {
    return a + b;
}

編譯為共享函式庫：

g++ -fPIC -shared -o libadd.so add.cpp

在 C# (.NET) 呼叫 C++ 函式庫

於 Program.cs 加入：

using System;
using System.Runtime.InteropServices;

class Program
{
    [DllImport("libadd.so", EntryPoint="add")]
    public static extern int Add(int a, int b);

    static void Main()
    {
        Console.WriteLine("3 + 5 = " + Add(3, 5));
    }
}

執行與測試

回到專案根目錄執行：

dotnet run

若輸出結果為 3 + 5 = 8，表示部署成功。

發佈部署版本

可將程式打包為可獨立執行的部署檔：

dotnet publish -c Release -r linux-x64 --self-contained true

生成的可執行檔位於 bin/Release/net8.0/linux-x64/publish/。

Docker 容器部署（選用）

可使用 Docker 將應用容器化，以便在任何 Ubuntu 系統運行：

# Dockerfile 範例
FROM mcr.microsoft.com/dotnet/runtime:8.0
WORKDIR /app
COPY ./publish .
COPY ./native/libadd.so /usr/lib/
ENTRYPOINT ["./MyApp"]

建構與執行容器：

docker build -t myapp .
docker run --rm myapp

注意事項

• C++/CLI 僅支援 Windows，無法直接於 Ubuntu 執行。
• 若需跨平台互通，建議使用 P/Invoke（C# 呼叫 C++）。
• Linux 使用 .so 函式庫，Windows 使用 .dll。
• 確保函式庫路徑包含於 LD_LIBRARY_PATH。

總結

部署 .NET C++ 程式至 Ubuntu 的可行方式通常是採「C# + C++ 原生函式庫」架構。若原始程式依賴 C++/CLI，需重新設計以支援跨平台 .NET。最推薦的方式是使用 .NET 8 + 原生 C++ 模組搭配 Docker，達到穩定、可攜且一致的部署流程。

軟體開發相關法律

著作權法

軟體程式碼、設計文件、使用手冊等均屬著作權保護範疇。著作權保護自創作完成時自動成立，無需註冊，禁止未經授權的複製、修改、散布或商業利用。

專利法

若軟體涉及技術創新或獨特演算法，可申請專利保護。專利需經審查批准，保障發明人對技術方案的專有權利，但純粹的程式邏輯通常不受專利保護。

商標法

軟體名稱、圖示（Logo）、品牌識別可註冊為商標，用以保護品牌形象與市場區隔，防止他人冒用造成混淆。

營業秘密保護法

未公開的程式設計細節、演算法、資料庫結構等屬營業秘密。公司應透過保密協議、資訊管理制度等方式保護。

資訊安全相關法規

如個資法、資通安全管理法等，要求軟體開發過程中妥善處理使用者個人資料、保障資訊安全，違規可能面臨行政或刑事責任。

契約法與授權條款

軟體開發常涉及承攬契約、合作開發契約、軟體授權條款等，明確雙方權利義務、程式碼所有權、維護責任、保密義務等，避免法律爭議。

網路與電子商務相關法規

軟體上線運營涉及網路服務、電子支付、智慧財產權線上保護等，需遵守電子簽章法、電子交易法等規範。

軟體開發的智慧財產權

著作權

軟體的程式碼屬於著作權保護的範疇，開發者自動擁有著作權，無需額外登記。著作權保護涵蓋原始碼、設計文件、使用手冊等。

專利權

若軟體涉及新穎性與技術創新，可能可申請專利保護。例如獨特的演算法或解決技術問題的方法，但純粹的程式碼邏輯通常不在專利保護範圍。

商標權

軟體名稱、圖示（Logo）可註冊為商標，用於區分不同來源的產品，避免市場混淆。

營業秘密

未公開的程式設計細節、資料庫結構、演算法可透過營業秘密方式保護。需依靠企業內部保密協議與管理措施維護。

授權模式

軟體可透過不同授權模式發行，例如專有軟體、自由軟體、開源授權（如GPL、MIT）。不同授權模式影響使用者的修改與再散布權利。

侵權風險

未經授權使用他人程式碼、圖像或演算法可能構成侵權。開發過程應確保程式碼來源合法，避免法律糾紛。

國際保護

智慧財產權具地域性，但可透過國際條約如伯恩公約、TRIPS協議在多國獲得一定程度的保護。

email: [email protected]

T:0000

資訊與搜尋
email: Yan Sa [email protected] Line: 阿央
電話: 02-27566655 ,03-5924828

阿央
泱泱科技
捷昱科技泱泱企業