Pointers ב-Golang: & ו-*, new, nil ומתי להשתמש בהם

& ו-*

pointer מחזיק את כתובת הזיכרון של ערך. &x נותן לכם pointer ל-x. *p הולך אחרי ה-pointer אל הערך.

package main

import "fmt"

func main() {
	x := 10
	p := &x // p has type *int

	fmt.Println(*p) // read through the pointer: 10
	*p = 20         // write through the pointer
	fmt.Println(x)  // x changed: 20

	fmt.Printf("%T\n", p)
	fmt.Println(p != nil)
}

לכוכבית יש שני תפקידים. בתוך טיפוס (*int) היא אומרת "pointer ל-int". בתוך ביטוי (*p) היא אומרת "הערך ש-p מצביע עליו". הדפסה של p עצמו מראה כתובת כמו 0xc000012345, שמשתנה בין הרצות.

למה pointers קיימים: שיתוף במקום העתקה

Go מעבירה הכול לפי ערך. פונקציה מקבלת עותק של כל ארגומנט, ולכן היא לא יכולה לשנות את המשתנה של הקוד הקורא. העברת pointer מעתיקה במקום זה את הכתובת, ושני הצדדים מגיעים לאותו ערך.

package main

import "fmt"

func doubleCopy(n int) {
	n *= 2
}

func doublePtr(n *int) {
	*n *= 2
}

func main() {
	v := 21
	doubleCopy(v)
	fmt.Println(v) // 21

	doublePtr(&v)
	fmt.Println(v) // 42
}

ב-Go אין references במובן של C++. "העברה לפי reference" ב-Go פירושה העברה של pointer לפי ערך.

Pointers ל-structs

pointers ל-structs הם ה-pointers הנפוצים ביותר בקוד Go. גישה לשדה מבצעת dereference אוטומטית: p.Name פירושו (*p).Name.

package main

import "fmt"

type Account struct {
	Owner   string
	Balance int
}

func (a *Account) Deposit(n int) {
	a.Balance += n // no explicit * needed
}

func main() {
	acc := &Account{Owner: "Ana"} // pointer to a new struct
	acc.Deposit(100)
	acc.Balance -= 30
	fmt.Println(acc.Owner, acc.Balance)

	same := acc
	same.Balance = 0
	fmt.Println(acc.Balance) // 0: both variables point at one Account
}

מתודות פועלות לפי אותו היגיון: pointer receiver מאפשר למתודה לשנות את ה-struct. העמוד על מתודות מסביר את הבחירה בין value receiver ל-pointer receiver.

new

new(T) מקצה T מאופס ומחזירה את הכתובת שלו. זה אותו דבר כמו להצהיר על משתנה ולקחת את הכתובת שלו.

p := new(int) // *int pointing at 0
var x int
q := &x           // same thing, two lines
a := new(Account) // same as &Account{}

בפועל &T{...} נפוץ יותר ל-structs, כי הוא מאפשר לקבוע שדות באותו ביטוי. new נוחה ל-pointers לטיפוסים בסיסיים. אל תבלבלו אותה עם make, שבונה slices, maps ו-channels ומחזירה אותם מוכנים לשימוש, לא כ-pointers.

בטוח להחזיר pointer למשתנה מקומי

ב-C, החזרת הכתובת של משתנה מקומי היא באג. ב-Go זה קוד רגיל.

package main

import "fmt"

type Config struct {
	Port int
	Mode string
}

func defaultConfig() *Config {
	c := Config{Port: 8080, Mode: "dev"}
	return &c // c outlives the call, so it lives on the heap
}

func main() {
	cfg := defaultConfig()
	cfg.Mode = "prod"
	fmt.Printf("%+v\n", *cfg)
}

ה-escape analysis של הקומפיילר מחליט אם ערך יחיה ב-stack או ב-heap. אתם אף פעם לא בוחרים, ואף פעם לא משחררים זיכרון: ה-garbage collector מחזיר אותו כששום דבר לא מצביע עליו. go build -gcflags=-m מדפיס את ההחלטות האלה, אם זה מסקרן אתכם.

pointers שהם nil

ערך האפס של כל טיפוס pointer הוא nil. dereference ל-nil נכנס ל-panic.

package main

import "fmt"

type Node struct {
	Val  int
	Next *Node
}

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	list := &Node{Val: 1, Next: &Node{Val: 2}}
	for n := list; n != nil; n = n.Next {
		fmt.Println(n.Val)
	}

	var missing *Node
	fmt.Println(missing == nil)
	fmt.Println(missing.Val) // panics
}

פלט:

1
2
true
recovered: runtime error: invalid memory address or nil pointer dereference

בלי ה-recover, התוכנית הייתה קורסת עם ההודעה הזאת ועם stack trace שמתחיל ב-panic: runtime error: invalid memory address or nil pointer dereference וב-[signal SIGSEGV: segmentation violation ...]. המקורות הרגילים:

• משתנה pointer או שדה ב-struct שאף פעם לא קיבלו ערך
• m[key] על map[string]*T עם מפתח חסר, שמחזיר nil
• התעלמות משגיאה: f, _ := os.Open(path) משאיר את f כ-nil בכישלון
• מתודה עם pointer receiver שנקראת על pointer שהוא nil, ואז קוראת שדה

קריאה למתודה על pointer שהוא nil היא כשלעצמה חוקית. ה-panic קורה רק כשהמתודה נוגעת בשדות של ה-receiver.

מתי להשתמש ב-pointer

השתמשו ב-pointer כש:

• פונקציה או מתודה צריכה לשנות את הערך של הקוד הקורא
• הערך הוא struct גדול שמועבר הרבה
• אסור להעתיק את הטיפוס (הוא מכיל sync.Mutex, או מייצג משאב ייחודי כמו חיבור)
• צריך לבטא "אין ערך" עם nil, למשל שדה אופציונלי ב-struct של JSON (*int מבחין בין "חסר" ל-0)

אל תשתמשו ב-pointer כש:

• הערך קטן ולקריאה בלבד (time.Time, Point)
• הטיפוס כבר מתנהג כמו הפניה: slices, maps, channels, פונקציות ו-interfaces כמעט אף פעם לא צריכים * לפניהם. *[]int או *map[string]int הם כמעט תמיד טעות

pointers לא מהירים יותר אוטומטית. העתקה של struct קטן זולה, ו-pointer יכול לכפות הקצאה ב-heap ולהוסיף עבודה ל-garbage collector.

pointers ומשתני לולאה

לקחת את הכתובת של משתנה לולאה זה בטוח מאז Go 1.22, כי לכל איטרציה יש משתנה משלה:

package main

import "fmt"

func main() {
	var ptrs []*int
	for i := range 3 {
		ptrs = append(ptrs, &i)
	}
	for _, p := range ptrs {
		fmt.Print(*p, " ")
	}
	fmt.Println()
}

זה מדפיס 0 1 2. לפני Go 1.22 (שגם הציגה את range 3), אותה לולאה שנכתבה כ-for i := 0; i < 3; i++ הדפיסה 3 3 3, כי שלושת ה-pointers חלקו משתנה אחד. שימו לב ש-&v ב-for _, v := range items מצביע על עותק של האיבר, לא על האיבר שב-slice. כדי לקבל pointer לאיבר עצמו, השתמשו ב-&items[i].

טעויות נפוצות

• dereference בלי בדיקה. בדקו if p == nil בכל מקום שבו nil אפשרי.
• pointer לערך של range. &v מצביע על עותק; השתמשו ב-&s[i].
• pointers ל-slices ול-maps. כמעט אף פעם לא נחוצים. החזירו במקום זה את ה-slice החדש.
• החזקת &s[i] לאורך append. אם append מקצה מחדש, ה-pointer עדיין מפנה למערך הישן, וכתיבות מאוחרות יותר הולכות למקום שלא רואים.