Go'da İşaretçi Temelleri

Coddy'nin GO Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası — ders 19 / 107.

Bir pointer, başka bir değişkenin bellek adresini saklayan bir değişkendir. Bir değeri doğrudan tutmak yerine, o değerin bellekte bulunduğu konumu tutar. Pointer'lar Go için temeldir ve verimli veri manipülasyonu için gereklidir.

Bir işaretçi oluşturmak için, bir değişkenin adresini almak üzere & operatörünü ve bir işaretçi türü bildirmek veya o adresteki değere erişmek için * operatörünü kullanın.

x := 42
p := &x  // p, x'in bellek adresini tutar

fmt.Println(p)  // 0xc000018030 (bellek adresi)
fmt.Println(*p) // 42 (o adresteki değer)

& operatörü "adresi" anlamına gelir ve bir işaretçi döndürür. * operatörü, bir işaretçi üzerinde kullanıldığında "konumundaki değer" anlamına gelir ve dereferencing olarak adlandırılır. Ayrıca işaretçi aracılığıyla orijinal değeri değiştirebilirsiniz.

x := 10
p := &x

*p = 25         // değeri işaretçi aracılığıyla değiştir
fmt.Println(x)  // 25 (orijinal değişken değişti)

İşaretçi türü, T işaret edilen tür olmak üzere *T şeklinde yazılır. Bir int işaretçisinin türü *int'tir.

var p *int      // int türünde bir işaretçi (pointer) tanımlar
x := 100
p = &x          // p artık x'i işaret ediyor

Bir işaretçinin (pointer) sıfır değeri nil'dir, yani hiçbir şeyi işaret etmediği anlamına gelir. Bir nil işaretçisinin değerine erişmeye (dereference) çalışmak bir çalışma zamanı paniğine (runtime panic) neden olur, bu nedenle işaretçilerin kullanılmadan önce her zaman başlatıldığından (initialized) emin olun.

Görev

Kolay

Değişkenleri bellek adresleri üzerinden değiştirmek için pointer'ların gücünü gösteren basit bir değer değiştirici (value swapper) oluşturalım.

Kodunuzu iki dosya halinde düzenleyeceksiniz:

swap.go: Parametre olarak iki adet *int pointer alan SwapValues adında bir fonksiyon oluşturun. Bu fonksiyon, bu pointer'ların işaret ettiği değerleri birbiriyle değiştirmelidir; fonksiyon çağrıldıktan sonra her değişken diğerinin orijinal değerini tutmalıdır. Fonksiyon herhangi bir değer döndürmez; değerleri doğrudan pointer'lar aracılığıyla değiştirir.
main.go: Girdiden iki tam sayı okuyun, bunları değişkenlerde saklayın ve ardından değerlerini değiştirmek için SwapValues fonksiyonunuzu kullanın. Değişikliği göstermek için her iki değeri de değiştirmeden önce ve değiştirdikten sonra yazdırın.

Aşağıdaki girdiler sağlanacaktır:

Satır 1: Birinci tam sayı
Satır 2: İkinci tam sayı

Çıktı formatı:

Before: a=[first] b=[second]
After: a=[first] b=[second]

Örneğin, 10 ve 25 verildiğinde, çıktınız şu şekilde olmalıdır:

Before: a=10 b=25
After: a=25 b=10

Değişkenlerinizi fonksiyona aktarırken & operatörünü, fonksiyon içinde ise gerçek değerlere erişmek ve bunları değiştirmek için * operatörünü kullanmayı unutmayın.

Kopya kağıdı

Bir pointer (işaretçi), başka bir değişkenin bellek adresini saklayan bir değişkendir. Bir değişkenin adresini almak için & operatörünü, bir pointer türü tanımlamak veya o adresteki değere erişmek için * operatörünü kullanın.

x := 42
p := &x  // p, x'in bellek adresini tutar

fmt.Println(p)  // 0xc000018030 (bellek adresi)
fmt.Println(*p) // 42 (o adresteki değer)

& operatörü "adresi" anlamına gelir ve bir pointer döndürür. * operatörü, bir pointer üzerinde kullanıldığında "adresteki değer" anlamına gelir ve buna dereferencing (referans çözme) denir.

Orijinal değeri pointer aracılığıyla değiştirebilirsiniz:

x := 10
p := &x

*p = 25         // pointer aracılığıyla değeri değiştir
fmt.Println(x)  // 25 (orijinal değişken değişti)

Pointer türü, T işaret edilen tür olmak üzere *T şeklinde yazılır:

var p *int      // int türünde bir pointer tanımlar
x := 100
p = &x          // p artık x'i işaret ediyor

Bir pointer'ın sıfır değeri (zero value) nil'dir. Bir nil pointer'ın referansını çözmeye çalışmak (dereference) çalışma zamanı paniğine (runtime panic) neden olur.

Kendin dene

package main

import "fmt"

func main() {
	// Girişten iki tam sayı oku
	var a, b int
	fmt.Scanln(&a)
	fmt.Scanln(&b)

	// Değişimden önceki değerleri yazdır
	fmt.Printf("Before: a=%d b=%d\n", a, b)

	// TODO: a ve b işaretçileri ile SwapValues fonksiyonunu çağır
	// Adresleri geçirmek için & operatörünü kullanmayı unutma

	// Değişimden sonraki değerleri yazdır
	fmt.Printf("After: a=%d b=%d\n", a, b)
}