آموزش اشاره‌گر در گولنگ - راهنمای کامل Pointer در Go

package main

import "fmt"

func main() {
    x := 42

    // دریافت آدرس با &
    ptr := &x

    fmt.Println("مقدار x:", x)          // 42
    fmt.Println("آدرس x:", &x)          // 0xc0000140a0
    fmt.Println("مقدار ptr:", ptr)      // 0xc0000140a0
    fmt.Println("مقدار در آدرس:", *ptr) // 42 (dereference)
}

package main

import "fmt"

func main() {
    // روش 1: تعریف و مقداردهی
    var x int = 10
    var ptr *int = &x

    // روش 2: استنتاج نوع
    y := 20
    ptr2 := &y

    // روش 3: pointer به struct
    type Person struct {
        Name string
        Age  int
    }
    p := Person{Name: "علی", Age: 25}
    pPtr := &p

    fmt.Printf("ptr: %T, value: %v\n", ptr, *ptr)
    fmt.Printf("ptr2: %T, value: %v\n", ptr2, *ptr2)
    fmt.Printf("pPtr: %T, name: %v\n", pPtr, pPtr.Name)
}

var ptr *int  // nil

if ptr == nil {
    fmt.Println("Pointer خالی است")
}

// دسترسی به nil pointer باعث panic می‌شود!
// fmt.Println(*ptr)  // panic: runtime error

package main

import "fmt"

func main() {
    x := 10
    ptr := &x

    // تغییر مقدار از طریق pointer
    *ptr = 20

    fmt.Println("x:", x)  // 20 (تغییر کرد!)
}

func double(x int) {
    x = x * 2  // فقط کپی تغییر می‌کند
}

func main() {
    num := 5
    double(num)
    fmt.Println(num)  // 5 (تغییر نکرد!)
}

func double(x *int) {
    *x = *x * 2  // مقدار اصلی تغییر می‌کند
}

func main() {
    num := 5
    double(&num)
    fmt.Println(num)  // 10 (تغییر کرد!)
}

func newInt(x int) *int {
    return &x  // در Go این امن است (escape analysis)
}

func main() {
    ptr := newInt(42)
    fmt.Println(*ptr)  // 42
}

package main

import "fmt"

type User struct {
    Name  string
    Email string
    Age   int
}

// با pointer - می‌تواند تغییر دهد
func (u *User) SetAge(age int) {
    u.Age = age
}

// بدون pointer - فقط خواندن
func (u User) GetInfo() string {
    return fmt.Sprintf("%s (%d)", u.Name, u.Age)
}

func main() {
    user := User{Name: "علی", Email: "ali@example.com", Age: 25}

    // Go خودکار & و * را مدیریت می‌کند
    user.SetAge(30)  // معادل (&user).SetAge(30)
    fmt.Println(user.GetInfo())  // علی (30)

    // کار با pointer
    userPtr := &user
    userPtr.Name = "رضا"  // معادل (*userPtr).Name
    fmt.Println(user.Name)  // رضا
}

// new یک pointer به مقدار صفر برمی‌گرداند
ptr := new(int)      // *int با مقدار 0
fmt.Println(*ptr)    // 0

*ptr = 42
fmt.Println(*ptr)    // 42

// معادل:
var x int
ptr2 := &x

// make مقدار واقعی برمی‌گرداند (نه pointer)
slice := make([]int, 5)     // []int
m := make(map[string]int)   // map[string]int
ch := make(chan int)        // chan int

x := 10
ptr := &x
ptrToPtr := &ptr

fmt.Println(x)          // 10
fmt.Println(*ptr)       // 10
fmt.Println(**ptrToPtr) // 10

**ptrToPtr = 20
fmt.Println(x)          // 20

func modifySlice(s []int) {
    s[0] = 100  // تغییر می‌دهد (slice reference است)
}

func main() {
    nums := []int{1, 2, 3}
    modifySlice(nums)
    fmt.Println(nums)  // [100 2 3]
}

func addToMap(m map[string]int) {
    m["new"] = 42  // تغییر می‌دهد
}

func main() {
    data := map[string]int{"a": 1}
    addToMap(data)
    fmt.Println(data)  // map[a:1 new:42]
}

func swap(a, b *int) {
    *a, *b = *b, *a
}

func main() {
    x, y := 10, 20
    swap(&x, &y)
    fmt.Println(x, y)  // 20 10
}

type Node struct {
    Value int
    Next  *Node
}

func main() {
    // ایجاد لیست: 1 -> 2 -> 3
    head := &Node{Value: 1}
    head.Next = &Node{Value: 2}
    head.Next.Next = &Node{Value: 3}

    // پیمایش
    current := head
    for current != nil {
        fmt.Println(current.Value)
        current = current.Next
    }
}

type Config struct {
    Host    string
    Port    *int    // اختیاری
    Timeout *int    // اختیاری
}

func NewConfig(host string, port, timeout *int) Config {
    return Config{
        Host:    host,
        Port:    port,
        Timeout: timeout,
    }
}

func main() {
    port := 8080
    config := NewConfig("localhost", &port, nil)

    if config.Port != nil {
        fmt.Println("Port:", *config.Port)
    }
    if config.Timeout == nil {
        fmt.Println("Timeout: default")
    }
}

type Counter struct {
    count int
}

// Value receiver - کپی می‌شود
func (c Counter) ValueIncrement() {
    c.count++  // فقط کپی تغییر می‌کند
}

// Pointer receiver - اصل تغییر می‌کند
func (c *Counter) PointerIncrement() {
    c.count++
}

func main() {
    counter := Counter{count: 0}

    counter.ValueIncrement()
    fmt.Println(counter.count)  // 0

    counter.PointerIncrement()
    fmt.Println(counter.count)  // 1
}

// این در Go امن است (بر خلاف C)
func createInt() *int {
    x := 42
    return &x  // Go به heap منتقل می‌کند
}

// این در Go کار نمی‌کند:
// ptr++
// ptr + 1

func process(ptr *int) {
    if ptr == nil {
        return
    }
    // کار با *ptr
}