المؤشرات في Golang: & و* وnew وnil ومتى تستخدمها

& و*

يحمل المؤشر (pointer) عنوان قيمة في الذاكرة. يعطيك &x مؤشرًا إلى x. ويتبع *p المؤشر إلى القيمة.

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) تعني "مؤشرًا إلى int". وفي التعبير (*p) تعني "القيمة التي يشير إليها p". طباعة p نفسه تعرض عنوانًا مثل 0xc000012345، يختلف بين التشغيلات.

لماذا توجد المؤشرات: المشاركة بدل النسخ

تمرّر Go كل شيء بالقيمة. تحصل الدالة على نسخة من كل وسيط، فلا تستطيع تغيير متغيّر المستدعي. تمرير مؤشر ينسخ العنوان بدلًا من ذلك، فيصل الطرفان إلى القيمة نفسها.

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 مراجع بمعنى C++. "التمرير بالمرجع" في Go يعني تمرير مؤشر بالقيمة.

المؤشرات إلى البنى

مؤشرات البنى أشيع المؤشرات في شيفرات Go. الوصول إلى الحقول يلغي المرجعية تلقائيًا: 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
}

تتبع التوابع المنطق نفسه: مستقبِل المؤشر يتيح للتابع تغيير البنية. تشرح صفحة التوابع الاختيار بين مستقبِل القيمة ومستقبِل المؤشر.

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{...} أشيع مع البنى لأنها تتيح ضبط الحقول في التعبير نفسه. وnew مفيدة للمؤشرات إلى الأنواع الأساسية. لا تخلطها بـ make، التي تبني الشرائح والخرائط والقنوات وتعيدها جاهزة للاستخدام، لا كمؤشرات.

إعادة مؤشر إلى متغيّر محلي آمنة

في 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) في المترجم هل تعيش القيمة في المكدّس أم في الكومة. لا تختار أنت أبدًا، ولا تحرّر الذاكرة أبدًا: يستعيدها جامع النفايات عندما لا يشير إليها شيء. يطبع go build -gcflags=-m هذه القرارات إن كنت فضوليًا.

المؤشرات nil

القيمة الصفرية لأي نوع مؤشر هي nil. وإلغاء مرجعية 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 كان البرنامج سينهار بتلك الرسالة وأثر مكدّس يبدأ بـ panic: runtime error: invalid memory address or nil pointer dereference و[signal SIGSEGV: segmentation violation ...]. المصادر المعتادة:

• متغيّر مؤشر أو حقل بنية لم يُضبط قط
• m[key] على map[string]*T لمفتاح مفقود، الذي يعيد nil
• تجاهل خطأ: f, _ := os.Open(path) تترك f مساويًا لـ nil عند الفشل
• تابع بمستقبِل مؤشر يُستدعى على مؤشر nil، ثم يقرأ حقلًا

استدعاء تابع على مؤشر nil مسموح بحد ذاته. لا تحدث panic إلا عندما يلمس التابع حقول المستقبِل.

متى تستخدم مؤشرًا

استخدم مؤشرًا عندما:

• يجب أن تغيّر دالة أو تابع قيمة المستدعي
• تكون القيمة بنية كبيرة تُمرَّر كثيرًا
• لا يجوز نسخ النوع (يحتوي sync.Mutex، أو يمثّل موردًا فريدًا مثل اتصال)
• تحتاج التعبير عن "لا قيمة" بـ nil، مثلًا حقل اختياري في بنية JSON (يميّز *int بين "غائب" و0)

لا تستخدم مؤشرًا عندما:

• تكون القيمة صغيرة وللقراءة فقط (time.Time، أو Point)
• يكون النوع أصلًا قيمة شبيهة بالمرجع: الشرائح والخرائط والقنوات والدوال والواجهات نادرًا ما تحتاج * أمامها. و*[]int أو *map[string]int خطأ في كل الحالات تقريبًا

المؤشرات ليست أسرع تلقائيًا. نسخ بنية صغيرة رخيص، وقد يفرض المؤشر حجزًا في الكومة ويضيف عملًا لجامع النفايات.

المؤشرات ومتغيّرات الحلقة

أخذ عنوان متغيّر الحلقة آمن منذ 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، لأن المؤشرات الثلاثة كانت تتشارك متغيّرًا واحدًا. لاحظ أن &v في for _, v := range items يشير إلى نسخة من العنصر، لا إلى العنصر في الشريحة. للحصول على مؤشر إلى العنصر نفسه استخدم &items[i].

أخطاء شائعة

• إلغاء المرجعية دون فحص. افحص if p == nil حيثما كانت nil ممكنة.
• مؤشر إلى قيمة range. يشير &v إلى نسخة؛ استخدم &s[i].
• المؤشرات إلى الشرائح والخرائط. نادرًا ما تُحتاج. أعد الشريحة الجديدة بدلًا من ذلك.
• الاحتفاظ بـ &s[i] عبر append. إذا أعادت append الحجز، يبقى المؤشر يشير إلى المصفوفة القديمة وتذهب الكتابات اللاحقة إلى مكان لا يُرى.