Golang

單元：指標與記憶體管理

主題：指標與函數參數

---

簡介

在 Go 語言中，**指標（pointer）**是連結變數與其底層記憶體位置的關鍵機制。雖然 Go 內建了垃圾回收（GC），但了解指標的行為仍是撰寫高效、可預測程式的基礎。特別是當我們把資料傳遞給函式時，是以值傳遞（pass‑by‑value）還是以指標傳遞（pass‑by‑reference），會直接影響程式的效能與可變性。

本篇文章將從指標的基本概念出發，說明如何在函式參數中使用指標、何時應該使用指標、以及常見的陷阱與最佳實踐，讓讀者能在實務開發中自信地運用這項特性。

---

核心概念

1. 為什麼要使用指標？

• 避免大量資料的複製：傳遞大型結構體或陣列時，若以值傳遞會產生完整的副本，增加記憶體與 CPU 開銷。
• 允許函式修改呼叫端的變數：只有指標才能讓函式直接改變外部變數的內容。
• 與內建資料結構（slice、map、channel）配合：這些類型本身就是指標封裝，了解指標概念有助於正確使用它們。

2. 指標的語法基礎

操作	說明
var p *int	宣告一個指向 int 的指標變數 p，預設值為 nil
p = &x	取得變數 x 的記憶體位址，並指派給 p
*p	透過指標 p 讀取或寫入 x 的值（解引用）
new(T)	分配一塊零值的記憶體，回傳 *T（常用於建立指標）

注意：Go 不支援指標算術（pointer arithmetic），這是為了避免記憶體安全問題。

3. 函式參數的傳遞方式

Go 的函式參數永遠是值傳遞。當我們把一個指標傳入函式時，實際傳遞的是指標本身的值（即位址），而不是指向的資料本身。這意味著：

func modify(v int) {        // v 為值的副本
    v = 100
}
func modifyPtr(p *int) {    // p 為指標的副本，指向同一塊記憶體
    *p = 100
}

• modify 改變的只是一個局部副本，呼叫端的變數不會受影響。
• modifyPtr 透過指標間接改變呼叫端變數的內容。

4. 常見的指標傳遞模式

模式	範例	何時使用
傳遞結構體指標	func UpdateUser(u *User) { u.Name = "Alice" }	大型結構體、需要在函式內部修改欄位
傳遞基本型別指標	func SetFlag(b *bool) { *b = true }	需要返回多個結果、或想避免回傳多值
傳遞切片指標	func AppendItem(s *[]int) { *s = append(*s, 42) }	想改變切片本身（重新分配）
傳遞介面指標	func Reset(w *bytes.Buffer) { w.Reset() }	介面本身已是指標封裝，通常不需要再取指標

---

程式碼範例

範例 1：基本指標操作

package main

import "fmt"

func main() {
    // 宣告變數
    a := 10
    // 取得 a 的位址
    p := &a
    fmt.Printf("a = %d, address = %p\n", a, p)

    // 透過指標修改 a
    *p = 20
    fmt.Printf("修改後 a = %d\n", a)
}

說明：&a 取得 a 的位址，*p 解引用後直接改變 a 的值。

範例 2：以指標作為函式參數，改變呼叫端變數

package main

import "fmt"

func swap(x, y *int) {
    *x, *y = *y, *x
}

func main() {
    a, b := 3, 7
    fmt.Printf("交換前 a=%d, b=%d\n", a, b)
    swap(&a, &b)               // 把位址傳入
    fmt.Printf("交換後 a=%d, b=%d\n", a, b)
}

重點：swap 只接收兩個 *int，但能直接改變 a、b 的內容，因為兩個指標指向同一塊記憶體。

範例 3：傳遞大型結構體指標以提升效能

package main

import (
    "fmt"
    "time"
)

type Matrix struct {
    data [1024][1024]float64
}

// 計算矩陣的對角線和（值傳遞會產生巨量複製）
func diagSumCopy(m Matrix) float64 {
    sum := 0.0
    for i := 0; i < 1024; i++ {
        sum += m.data[i][i]
    }
    return sum
}

// 使用指標（只傳遞位址）
func diagSumPtr(m *Matrix) float64 {
    sum := 0.0
    for i := 0; i < 1024; i++ {
        sum += m.data[i][i]
    }
    return sum
}

func main() {
    var m Matrix
    // 填入測試資料
    for i := 0; i < 1024; i++ {
        for j := 0; j < 1024; j++ {
            m.data[i][j] = float64(i*j) / 1e6
        }
    }

    start := time.Now()
    _ = diagSumCopy(m) // 複製整個 Matrix
    fmt.Println("Copy 耗時:", time.Since(start))

    start = time.Now()
    _ = diagSumPtr(&m) // 只傳遞指標
    fmt.Println("Ptr  耗時:", time.Since(start))
}

結果：在大型結構體上，指標傳遞可減少記憶體拷貝，執行速度顯著提升。

範例 4：指標與 nil 檢查

package main

import "fmt"

type Node struct {
    Value int
    Next  *Node
}

// 建立單向鏈結串列
func appendNode(head **Node, v int) {
    if *head == nil {
        *head = &Node{Value: v}
        return
    }
    cur := *head
    for cur.Next != nil {
        cur = cur.Next
    }
    cur.Next = &Node{Value: v}
}

func main() {
    var head *Node // 初始為 nil
    appendNode(&head, 1)
    appendNode(&head, 2)
    appendNode(&head, 3)

    // 列印鏈結串列
    for p := head; p != nil; p = p.Next {
        fmt.Print(p.Value, " ")
    }
}

說明：appendNode 需要 指向指標的指標（**Node），才能在 head 為 nil 時直接建立第一個節點。

範例 5：使用 new 建立指標

package main

import "fmt"

func main() {
    // 使用 new 分配一個 int，預設值為 0
    p := new(int)
    fmt.Printf("new int: %d, address: %p\n", *p, p)

    // 直接寫入值
    *p = 42
    fmt.Println("更新後:", *p)
}

提醒：new(T) 與 &T{} 的差異在於前者回傳 零值指標，後者可同時初始化欄位。

---

常見陷阱與最佳實踐

陷阱	說明	改善方式
指標為 nil 卻未檢查	直接解引用會產生 runtime panic。	在使用前加 if p == nil { … }，或使用 errors.New 回傳錯誤。
不必要的指標	小型基本型別（如 int、bool）傳遞指標會增加程式碼複雜度且無效能提升。	只在需要修改呼叫端或避免大量複製時使用指標。
指標逃逸到堆上	若指標在函式外被保存，編譯器會將其「逃逸」至堆，可能增加 GC 壓力。	使用 go vet -escape 或 -gcflags=-m 檢查逃逸情形，盡量在需要長期保存時使用結構體指標。
多層指標混亂	**T、***T 難以閱讀且易錯。	盡量保持單層指標，若需要修改指標本身，考慮返回新指標或使用容器（slice、map）。
切片指標 vs 切片本身	切片已是指向底層陣列的描述子，直接傳遞切片即可修改其元素；若想改變切片長度或容量，需要傳遞 *[]T。	明確區分「修改元素」與「重新分配切片」的需求。

最佳實踐

1. 預設值傳遞：除非有明確的效能或可變性需求，先使用值傳遞。
2. nil 安全：所有接受指標的函式，都應在最前面檢查 nil，或在文件中明確說明不接受 nil。
3. 使用 make 建立 slice、map、channel：這些內建類型本身已是指標封裝，避免額外的 new。
4. 盡量避免全域指標：全域變數若是指標，會讓 GC 難以回收，增加記憶體佔用。
5. 利用工具：go vet、golangci-lint、staticcheck 能偵測指標使用的常見問題。

---

實際應用場景

1. 資料庫模型的更新

   func UpdateUser(u *User) error {
       // 只傳遞指標，避免整個 User 結構體被複製
       u.UpdatedAt = time.Now()
       return repo.Save(u)   // repo.Save 接受 *User
   }
   

   大型模型（含多個欄位）若以值傳遞會產生不必要的記憶體拷貝。

2. 佇列（Queue）或緩衝區的共享
   多個 goroutine 需要同時寫入同一個緩衝區，使用指標傳遞給工作者函式，配合 sync.Mutex 或 channel 保證安全。

3. 設定參數的可選欄位

   type Config struct {
       Timeout *time.Duration // nil 表示使用預設值
   }
   func NewClient(cfg Config) *Client { … }
   

   透過指標讓呼叫端能夠「不設定」某些欄位，而不是使用零值（0）造成語意混淆。

4. 遞迴資料結構（樹、圖）
   節點之間的關聯必須使用指標，否則會產生大量的副本，且無法正確建立循環參考。

5. 測試中的 Mock 物件
   測試時常需要把介面的實作指標傳入被測函式，以便在測試結束後檢查其內部狀態。

---

總結

• 指標是 Go 中連結變數與記憶體的橋樑，理解它的行為是寫出高效能程式的前提。
• 函式參數永遠是值傳遞，但傳遞指標本身的值（位址）讓我們能在函式內部修改外部變數。
• 在 大型結構體、需要修改呼叫端、或需要避免大量拷貝 時，使用指標是合理且必要的選擇。
• 避免常見陷阱（如未檢查 nil、不必要的多層指標、指標逃逸）能提升程式的安全性與可維護性。
• 最佳實踐 包括先以值傳遞、在需要時才使用指標、利用工具檢查逃逸與潛在錯誤。

掌握指標與函式參數的使用技巧後，你將能在日常開發、效能優化以及設計彈性 API 時更加得心應手。祝你在 Golang 的旅程中寫出更乾淨、更高效的程式碼！