Go'da pointerler nasıl çalışır?

Question

Accepted Answer

Bir **pointer**, bir değerin kendisinden ziyade hafızadaki **adresini** tutar. Go'da pointerler vardır (C gibi) ancak bunları basit ve güvenli tutar — pointer aritmetiği yoktur ve çöp toplayıcı hafızayı yönetir. Verileri verimli bir şekilde paylaşmak ve değiştirmek için kullanılırlar.

## İki operator: & ve *

```go
x := 42
p := &x          // & = "address of" → p is a *int (pointer to x)
fmt.Println(p)   // 0xc0000... (the address)
fmt.Println(*p)  // 42 — * = "dereference" (get the value at the address)

*p = 100         // change the value THROUGH the pointer
fmt.Println(x)   // 100 — x was modified via p
```

`&` bir değişkenin adresini alır; `*` (bir pointer üzerinde) işaret ettiği değere erişir veya onu ayarlar.

## Pointerler neden önemli: fonksiyonlar aracılığıyla değiştirme

```go
// ❌ value parameter — the function gets a COPY; changes don't affect the caller
func incrementValue(n int) { n++ }       // caller's variable unchanged

// ✅ pointer parameter — the function can modify the caller's variable
func incrementPointer(n *int) { *n++ }

x := 5
incrementValue(x)     // x still 5
incrementPointer(&x)  // x is now 6
```

Go argümanları **değere göre** (kopyalar) ilettiğinden, bir fonksiyon yalnızca çağıran tarafından sağlanan **pointer** ile verileri değiştirebilir. Bu, pointerları kullanmanın birincil nedenidir.

## Structlarla pointerler (çok yaygın)

```go
type Counter struct { count int }

// pointer receiver → method can modify the struct
func (c *Counter) Increment() { c.count++ }

c := &Counter{}      // a pointer to a Counter
c.Increment()        // modifies it (Go auto-dereferences: (*c).count++)
```

Pointer receiverlar, metodların structlarını nasıl değiştirdiğidir ve struct pointerlarını iletmek büyük structları kopyalamaktan kaçınır.

## nil pointer ve sıfır değeri

```go
var p *int           // zero value of a pointer is nil
fmt.Println(p)       // <nil>
*p = 5               // 💥 PANIC: nil pointer dereference (no value to point to)
if p != nil { *p = 5 }   // guard against nil
```

Bir `nil` pointera referans kaldırma paniğe neden olur — korunması gereken yaygın bir çalışma zamanı hatasıdır.

## Go pointerlarının SAHİP olmadığı şeyler (güvenlik)

```text
✗ NO pointer arithmetic (can't do p++ to move through memory like C)
✗ NO manual free — garbage collector reclaims memory
→ Pointers are about sharing/modifying data, not low-level memory hacking
```

## Neden önemli

Pointerler Go'da iki ana amaç için gereklidir: çağıranın verilerini **değiştirmek** (Go değere göre ilettiğinden, yalnızca bir pointer bir fonksiyonun orijinali değiştirmesine izin verir) ve **verimlilik** (bir pointeri iletmek büyük structları kopyalamaktan kaçınır).

Bunlar pointer receiverları olan metodlar (structları değiştirmenin standart yolu) için temeldir ve idiyomatik Go'da her yerde görülür.

`&`/`*`, değer-ve-pointer semantiğini, nil-pointer panikini ve Go pointerlarının bilinçli olarak *güvenli* (aritmetik yok, GC-yönetilen) — C tarzı hafıza manipülasyonundan ziyade paylaşma/değiştirmeye odaklanmış — anlamayı, doğru ve verimli Go yazması için temel bilgi ve başlangıçta ve röportajlarda sık oluşan bir kafa karışıklığı noktasıdır.