ਗੋ ਵਿੱਚ ਪੁਆਇੰਟਰ ਕਿਵੇਂ ਕਾਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

ਇੱਕ **ਪੁਆਇੰਟਰ** ਕਿਸੇ ਮੁੱਲ ਦਾ **ਮੈਮੋਰੀ ਐਡਰੈਸ** ਰੱਖਦਾ ਹੈ, ਖੁਦ ਮੁੱਲ ਦੀ ਬਜਾਏ। ਗੋ ਵਿੱਚ ਪੁਆਇੰਟਰ ਹਨ (ਸੀ ਵਾਂਗ) ਪਰ ਇਹ ਉਨ੍ਹਾਂ ਨੂੰ ਸਧਾਰਨ ਅਤੇ ਸੁਰੱਖਿਅਤ ਰੱਖਦੇ ਹਨ — ਕੋਈ ਪੁਆਇੰਟਰ ਅੰਕਗਣਿਤ ਨਹੀਂ, ਅਤੇ ਗਾਰਬੇਜ ਕਲੈਕਟਰ ਮੈਮੋਰੀ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ। ਇਹ ਡਾਟਾ ਨੂੰ ਸਾਂਝਾ ਕਰਨ ਅਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੋਧਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।

## ਦੋ ਓਪਰੇਟਰ: & ਅਤੇ *

```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
```

`&` ਕਿਸੇ ਵੇਰੀਏਬਲ ਦਾ ਐਡਰੈਸ ਲੈਂਦਾ ਹੈ; `*` (ਪੁਆਇੰਟਰ ਉੱਤੇ) ਜਿਸ ਮੁੱਲ ਦੀ ਸੁਚਕ ਕਰ ਰਿਹਾ ਹੈ ਉਸ ਨੂੰ ਐਕਸੈਸ ਕਰਦਾ ਜਾਂ ਸੈਟ ਕਰਦਾ ਹੈ।

## ਕਿਉਂ ਪੁਆਇੰਟਰ ਮਹੱਤਵਪੂਰਨ ਹਨ: ਫੰਕਸ਼ਨਾਂ ਦੁਆਰਾ ਸੋਧ

```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
```

ਕਿਉਂਕਿ ਗੋ ਆਰਗੁਮੈਂਟਾਂ ਨੂੰ **ਮੁੱਲ ਦੁਆਰਾ** (ਕਾਪੀਆਂ) ਪਾਸ ਕਰਦਾ ਹੈ, ਇੱਕ ਫੰਕਸ਼ਨ ਸਿਰਫ ਕਾਲ ਕਰਨ ਵਾਲੇ ਦੇ ਡਾਟਾ ਨੂੰ ਤਦ ਹੀ ਸੋਧ ਸਕਦਾ ਹੈ ਜੇ ਇਹ ਉਸ ਤੱਕ ਇੱਕ **ਪੁਆਇੰਟਰ** ਪ੍ਰਾਪਤ ਕਰੇ। ਇਹ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਮੁੱਖ ਕਾਰਨ ਹੈ।

## structs ਨਾਲ ਪੁਆਇੰਟਰ (ਬਹੁਤ ਆਮ)

```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++)
```

ਪੁਆਇੰਟਰ ਰੀਸੀਵਰ ਉਹ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਮੈਥਡ ਆਪਣੇ struct ਨੂੰ ਬਦਲਦੇ ਹਨ, ਅਤੇ struct ਪੁਆਇੰਟਰ ਨੂੰ ਪਾਸ ਕਰਨਾ ਵਡੇ structs ਨੂੰ ਕਾਪੀ ਕਰਨ ਤੋਂ ਬਚਦਾ ਹੈ।

## nil ਪੁਆਇੰਟਰ ਅਤੇ ਜ਼ੀਰੋ ਮੁੱਲ

```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
```

`nil` ਪੁਆਇੰਟਰ ਨੂੰ dereference ਕਰਨਾ ਪੈਨਿਕ ਕਰਦਾ ਹੈ — ਇੱਕ ਆਮ ਰਨਟਾਇਮ ਗਲਤੀ ਜਿਸਦੇ ਖਿਲਾਫ ਸੁਰੱਖਿਆ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

## ਗੋ ਪੁਆਇੰਟਰ ਕੀ ਨਹੀਂ ਕਰ ਸਕਦੇ (ਸੁਰੱਖਿਆ)

```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
```

## ਕਿਉਂ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਪੁਆਇੰਟਰ ਗੋ ਵਿੱਚ ਦੋ ਮੁੱਖ ਮਕਸਦਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹਨ: **ਕਾਲ ਕਰਨ ਵਾਲੇ ਦੇ ਡਾਟਾ ਨੂੰ ਸੋਧਣਾ** (ਕਿਉਂਕਿ ਗੋ ਮੁੱਲ ਦੁਆਰਾ ਪਾਸ ਕਰਦਾ ਹੈ, ਸਿਰਫ ਇੱਕ ਪੁਆਇੰਟਰ ਫੰਕਸ਼ਨ ਨੂੰ ਅਸਲ ਨੂੰ ਬਦਲਣ ਦਿੰਦਾ ਹੈ) ਅਤੇ **ਕੁਸ਼ਲਤਾ** (ਪੁਆਇੰਟਰ ਨੂੰ ਪਾਸ ਕਰਨਾ ਵਡੇ structs ਨੂੰ ਕਾਪੀ ਕਰਨ ਤੋਂ ਬਚਦਾ ਹੈ)।

ਇਹ ਪੁਆਇੰਟਰ ਰੀਸੀਵਰ ਨਾਲ ਮੈਥਡਾਂ ਲਈ ਬੁਨਿਆਦੀ ਹਨ (structs ਨੂੰ ਬਦਲਣ ਦਾ ਮਾਨਕ ਤਰੀਕਾ) ਅਤੇ ਪੂਰੇ idiomatic ਗੋ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ।

`&`/`*` ਨੂੰ ਸਮਝਣਾ, value-vs-pointer ਸਿੰਟੈਕਸ, nil-pointer panic, ਅਤੇ ਇਹ ਕਿ ਗੋ ਪੁਆਇੰਟਰ ਜਾਣ-ਬੁੱਝ ਕੇ *ਸੁਰੱਖਿਅਤ* ਹਨ (ਕੋਈ ਅੰਕਗਣਿਤ ਨਹੀਂ, GC-ਪ੍ਰਬੰਧਿਤ) — ਸੀ-ਸ਼ੈਲੀ ਮੈਮੋਰੀ ਹੇਰਾ-ਫੇਰੀ ਦੀ ਬਜਾਏ ਸ਼ੇਅਰਿੰਗ/ਮਿਉਟੇਸ਼ਨ ਉੱਤੇ ਫੋਕਸ ਕਰਨਾ — ਸਹੀ, ਕੁਸ਼ਲ ਗੋ ਲਿਖਣ ਲਈ ਮੂਲ ਜਾਣਕਾਰੀ ਹੈ ਅਤੇ ਨਵੀਆਂ ਵਿਚ ਅਤੇ ਇਨਟਰਵਿਊਆਂ ਵਿੱਚ ਵਿਤ-ਵਿਤੁਆ ਦਾ ਆਮ ਬਿੰਦੂ ਹੈ।