Go मध्ये पॉइंटर कसे कार्य करतात?

Question

Accepted Answer

**पॉइंटर** मूल्य स्वतःच्या ऐवजी मूल्याचा **मेमरी पत्ता** धारण करतो. Go मध्ये पॉइंटर आहेत (C प्रमाणे) परंतु ते सोपे आणि सुरक्षित ठेवतात — कोणतेही पॉइंटर अंकगणित नाही, आणि कचरा संग्राहक मेमरी हाताळतो. डेटा कार्यक्षमतेने साझा आणि संपादित करण्यासाठी त्यांचा उपयोग केला जातो.

## दोन ऑपरेटर: & आणि *

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

Go **मूल्य द्वारे** प्रत्येक लेख पास करतो (प्रती), एक कार्य केवळ कॉलरचा डेटा संपादित करू शकते जर त्याला त्याचा **पॉइंटर** मिळालेला असेल. हे पॉइंटर वापरण्याचे प्राथमिक कारण आहे.

## स्ट्रक्चसह पॉइंटर (अत्यंत सामान्य)

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

पॉइंटर रिसीव्हर हा तरीका आहे ज्या रีतीने पद्धती त्यांच्या स्ट्रक्चला परिवर्तित करतात, आणि स्ट्रक्चर पॉइंटर पास करणे मोठ्या स्ट्रक्चसची प्रतिलिपी करणे टाळते.

## 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` पॉइंटर डेरेफरेन्स करणे घबराटे — एक सामान्य रनटाइम त्रुटी ज्यापासून संरक्षण करणे आवश्यक आहे.

## Go पॉइंटर्स काय न करता (सुरक्षा)

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

## हे का महत्वाचे आहे

पॉइंटर Go मध्ये दोन मुख्य उद्देशांसाठी आवश्यक आहेत: कॉलरचा डेटा **सुधार** करणे (कारण Go मूल्य द्वारे पास करतो, केवळ पॉइंटर कार्याला मूळ सुधार करू देते) आणि **कार्यक्षमता** (पॉइंटर पास करणे मोठ्या स्ट्रक्चसची प्रतिलिपी करणे टाळते).

ते पॉइंटर रिसीव्हर सह पद्धतींसाठी आवश्यक आहेत (स्ट्रक्चसला संपादित करण्याचा मानक मार्ग) आणि समग्र idiometical Go मध्ये दिसतात.

`&`/`*`, मूल्य-बनाम-पॉइंटर अर्थ शास्त्र, nil-पॉइंटर घबराटे आणि हे की Go पॉइंटर्स मुद्दाम *सुरक्षित* आहेत (कोणतेही अंकगणित नाही, GC-व्यवस्थापित) — C-स्टाइल मेमरी हेराफेरीपेक्षा शेयरिंग/परिवर्तन केंद्रित — सभ्य, कार्यक्षम Go लिहिण्यासाठी मुख्य ज्ञान आहे आणि नवखान आणि साक्षात्कारांमध्ये गोंधळाचा एक वारंवार बिंदू आहे.