Golang Pointer'lar: & ve *, new, nil ve Ne Zaman Kullanılır

& ve *

Bir pointer bir değerin bellek adresini tutar. &x size x'e bir pointer verir. *p pointer'ı izleyerek değere ulaşır.

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)
}

Yıldızın iki rolü vardır. Bir tipte (*int) "int'e pointer" anlamına gelir. Bir ifadede (*p) "p'nin işaret ettiği değer" anlamına gelir. p'nin kendisini yazdırmak 0xc000012345 gibi, çalıştırmadan çalıştırmaya değişen bir adres gösterir.

Pointer'lar neden var: kopyalamak yerine paylaşmak

Go her şeyi değerle aktarır. Bir fonksiyon her argümanın bir kopyasını alır, bu yüzden çağıranın değişkenini değiştiremez. Bir pointer aktarmak bunun yerine adresi kopyalar ve iki taraf da aynı değere ulaşır.

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'da C++ anlamında referanslar yoktur. Go'da "referansla aktarım", bir pointer'ı değerle aktarmak demektir.

Struct pointer'ları

Struct pointer'ları Go kodunda en yaygın pointer'lardır. Alan erişimi otomatik olarak dereference eder: p.Name, (*p).Name demektir.

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
}

Metotlar da aynı mantığı izler: bir pointer alıcı, metodun struct'ı değiştirmesine izin verir. Değer ve pointer alıcı arasındaki seçimi metotlar sayfası anlatıyor.

new

new(T) sıfırlanmış bir T ayırır ve adresini döndürür. Bir değişken tanımlayıp adresini almakla aynıdır.

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

Pratikte struct'lar için &T{...} daha yaygındır, çünkü alanları aynı ifadede ayarlamanıza izin verir. new temel tiplere pointer'lar için kullanışlıdır. Onu, slice'ları, map'leri ve channel'ları oluşturup pointer olarak değil kullanıma hazır olarak döndüren make ile karıştırmayın.

Yerel bir değişkene pointer döndürmek güvenlidir

C'de yerel bir değişkenin adresini döndürmek bir hatadır. Go'da sıradan bir koddur.

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)
}

Derleyicinin escape analizi, bir değerin stack'te mi yoksa heap'te mi yaşayacağına karar verir. Siz asla seçmezsiniz ve belleği asla serbest bırakmazsınız: ona hiçbir şey işaret etmediğinde çöp toplayıcı onu geri alır. Merak ediyorsanız go build -gcflags=-m bu kararları yazdırır.

nil pointer'lar

Her pointer tipinin sıfır değeri nil'dir. Nil'i dereference etmek panic'e yol açar.

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
}

Çıktı:

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

recover olmasaydı program bu mesajla ve panic: runtime error: invalid memory address or nil pointer dereference ile [signal SIGSEGV: segmentation violation ...] ile başlayan bir stack trace ile çökerdi. Olağan kaynaklar:

• hiç ayarlanmamış bir pointer değişkeni ya da struct alanı
• eksik bir anahtar için bir map[string]*T üzerinde nil döndüren m[key]
• bir hatayı yok saymak: f, _ := os.Open(path) başarısızlıkta f'yi nil bırakır
• nil bir pointer üzerinde çağrılan ve sonra bir alanı okuyan pointer alıcılı bir metot

Nil bir pointer üzerinde metot çağırmanın kendisi geçerlidir. Panic yalnızca metot alıcının alanlarına dokunduğunda olur.

Pointer ne zaman kullanılır

Pointer kullanın, eğer:

• bir fonksiyon ya da metot çağıranın değerini değiştirmek zorundaysa
• değer büyük bir struct'sa ve sık sık aktarılıyorsa
• tip kopyalanmamalıysa (bir sync.Mutex içeriyorsa ya da bir bağlantı gibi benzersiz bir kaynağı temsil ediyorsa)
• "değer yok"u nil ile ifade etmeniz gerekiyorsa, örneğin bir JSON struct'ında isteğe bağlı bir alan (*int, "yok" ile 0'ı ayırt eder)

Pointer kullanmayın, eğer:

• değer küçük ve salt okunursa (time.Time, bir Point)
• tip zaten referans benzeri bir değerse: slice'lar, map'ler, channel'lar, fonksiyonlar ve interface'lerin önüne nadiren * gerekir. Bir *[]int ya da *map[string]int neredeyse her zaman bir hatadır

Pointer'lar kendiliğinden daha hızlı değildir. Küçük bir struct'ı kopyalamak ucuzdur, bir pointer ise heap ayırmayı zorunlu kılıp çöp toplayıcıya iş ekleyebilir.

Pointer'lar ve döngü değişkenleri

Bir döngü değişkeninin adresini almak Go 1.22'den beri güvenlidir, çünkü her yinelemenin kendi değişkeni vardır:

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()
}

Bu 0 1 2 yazdırır. Go 1.22'den önce (range 3 de o sürümde geldi) for i := 0; i < 3; i++ ile yazılmış aynı döngü 3 3 3 yazdırıyordu, çünkü üç pointer da tek bir değişkeni paylaşıyordu. for _, v := range items içindeki &v'nin slice'taki elemana değil, elemanın bir kopyasına işaret ettiğine dikkat edin. Elemanın kendisine pointer almak için &items[i] kullanın.

Sık yapılan hatalar

• Kontrol etmeden dereference etmek. Nil'in mümkün olduğu her yerde if p == nil kontrolü yapın.
• Bir range değerine pointer. &v bir kopyaya işaret eder; &s[i] kullanın.
• Slice'lara ve map'lere pointer'lar. Nadiren gerekir. Bunun yerine yeni slice'ı döndürün.
• Bir append boyunca &s[i]'yi tutmak. append yeniden ayırırsa pointer hâlâ eski diziye işaret eder ve sonraki yazmalar görünür hiçbir yere gitmez.