Ko'rsatkichlar

Ko'rsatkich - bu qiymatning manzili. Go da ular bor, lekin C dagiga qaraganda ancha xavfsiz.

Muammo: hamma narsa nusxalanadi #

package main

import "fmt"

func oshir(son int) {
    son = son + 10
}

func main() {
    ball := 50
    oshir(ball)
    fmt.Println(ball)
}

50

Hech narsa o'zgarmadi. oshir funksiyasi ball ning nusxasini oldi va o'sha nusxani o'zgartirdi.

Go da hamma narsa qiymat bo'yicha uzatiladi. Istisno yo'q.

Yechim: manzilni uzatish #

package main

import "fmt"

func oshir(son *int) {
    *son = *son + 10
}

func main() {
    ball := 50
    oshir(&ball)
    fmt.Println(ball)
}

60

Ikkita yangi belgi bor:

* belgisi ikki xil ma'noda ishlatiladi: tur yozilishida (*int) va qiymatga murojaatda (*son).

Ko'rsatkichni ko'rish #

package main

import "fmt"

func main() {
    ball := 50
    manzil := &ball

    fmt.Println(ball)
    fmt.Println(*manzil)
    fmt.Println(manzil == &ball)

    *manzil = 75
    fmt.Println(ball)
}

50
50
true
75

manzil va &ball - bir xil narsa. *manzil orqali yozganingizda, ball ning o'zi o'zgaradi.

nil ko'rsatkich #

package main

import "fmt"

func main() {
    var manzil *int

    fmt.Println(manzil == nil)

    ball := 42
    manzil = &ball
    fmt.Println(manzil == nil, *manzil)
}

true
false 42

Ko'rsatkichning nol qiymati - nil, ya'ni "hech qayerga ko'rsatmaydi".

panic: runtime error: invalid memory address or nil pointer dereference

if manzil != nil {
    fmt.Println(*manzil)
}

Funksiyada tuzilmani o'zgartirish #

package main

import "fmt"

type Talaba struct {
    Ism  string
    Ball int
}

func oshirNusxa(t Talaba) {
    t.Ball += 10
}

func oshirManzil(t *Talaba) {
    t.Ball += 10
}

func main() {
    talaba := Talaba{Ism: "Aziza", Ball: 80}

    oshirNusxa(talaba)
    fmt.Println("Nusxadan keyin:", talaba.Ball)

    oshirManzil(&talaba)
    fmt.Println("Manzildan keyin:", talaba.Ball)
}

Nusxadan keyin: 80
Manzildan keyin: 90

Bu ko'rsatkichlarning eng ko'p uchraydigan ishlatilishi. Strukturalarni 11-bo'limda batafsil o'rganamiz.

Ko'rsatkich qaytaruvchi funksiya #

package main

import "fmt"

type Talaba struct {
    Ism  string
    Ball int
}

func yangiTalaba(ism string) *Talaba {
    t := Talaba{Ism: ism, Ball: 0}
    return &t
}

func main() {
    a := yangiTalaba("Kamola")
    a.Ball = 95

    fmt.Println(a.Ism, a.Ball)
}

Kamola 95

new funksiyasi #

package main

import "fmt"

func main() {
    manzil := new(int)
    fmt.Println(*manzil)

    *manzil = 42
    fmt.Println(*manzil)

    ball := 42
    boshqa := &ball
    fmt.Println(*boshqa)
}

0
42
42

new(int) - yangi int yaratib, uning manzilini qaytaradi. Qiymat nol bo'ladi.

Amalda new kam ishlatiladi: &Talaba{...} shakli ancha qulayroq, chunki qiymatlarni darhol berish mumkin.

Ko'rsatkich arifmetikasi yo'q #

p++;        // C da: keyingi elementga o'tadi
*(p + 3)    // C da: uchinchi qo'shnini o'qiydi

Qachon ko'rsatkich ishlatish kerak #

Slice va map - alohida holat #

package main

import "fmt"

func ozgartir(royxat []int) {
    royxat[0] = 999
}

func main() {
    sonlar := []int{1, 2, 3}
    ozgartir(sonlar)
    fmt.Println(sonlar)
}

[999 2 3]

Bu yerda & yozilmagan, lekin o'zgarish saqlanib qoldi.

Sababi: slice ichida haqiqiy ma'lumotga ko'rsatkich saqlanadi. Slice ning o'zi nusxalandi, lekin nusxa ham o'sha ma'lumotga ko'rsatadi.

Xuddi shunday map va kanal ham. Buni keyingi ikki bo'limda batafsil ko'ramiz.

Xulosa #

• Go da hamma narsa qiymat bo'yicha uzatiladi - funksiya nusxa oladi.
• &qiymat manzilni beradi, *manzil esa manzildagi qiymatga boradi.
• Ko'rsatkichning nol qiymati - nil; undan o'qish vahima keltiradi.
• Go ko'rsatkich orqali maydonga murojaatni o'zi hal qiladi: t.Ball yetarli.
• Mahalliy o'zgaruvchining manzilini qaytarish xavfsiz - Go kerak bo'lsa uni uyumga ko'chiradi.
• Ko'rsatkich arifmetikasi yo'q - bu ataylab, xavfsizlik uchun.
• Shubhalansangiz qiymat ishlating; ko'rsatkich - o'zgartirish yoki katta struktura uchun.
• slice, map va kanal ichida allaqachon ko'rsatkich bor.

Keyingi bo'limda massivlar va slicelarni o'rganamiz.