Bagaimanakah penunjuk digunakan dalam bahasa Go?

Bahasa Go ialah bahasa yang selamat dan cekap Ia menyediakan penunjuk sebagai jenis data, membolehkan pengaturcara mengawal penggunaan memori dengan lebih sepenuhnya. Penunjuk ialah ciri penting dalam bahasa Go dan menguasai penggunaan penunjuk ialah kursus yang diperlukan untuk setiap pembangun Go. Artikel ini akan memperkenalkan cara menggunakan penunjuk dalam bahasa Go.

Apakah penunjuk?

Ringkasnya, penunjuk ialah pembolehubah yang menunjuk ke alamat memori. Untuk pembolehubah, kita boleh menggunakan operator & untuk mendapatkan alamat memorinya, dan pembolehubah penunjuk ialah pembolehubah yang menyimpan alamat memori ini. Melalui penunjuk, kita boleh terus mengakses nilai dalam alamat memori yang sepadan dan mengubah suai nilai ini. Ini adalah fungsi paling asas yang boleh diberikan oleh penuding.

Mengisytiharkan penunjuk

Dalam bahasa Go, mengisytiharkan penunjuk perlu dikenal pasti dengan menggunakan operator *. Contohnya:

var ptr *int   // 声明一个指向int型变量的指针

Pembolehubah ptr diisytiharkan di sini, iaitu penunjuk integer, maksudnya, ptr menyimpan alamat memori pembolehubah integer.

Penunjuk kendalian

Operasi asas penunjuk termasuk mendapatkan alamat, menukar jenis, mendapatkan nilai, dsb.

Dapatkan alamat

Gunakan & operator untuk mendapatkan alamat memori pembolehubah, seperti:

var a int = 10
var ptr *int // 声明一个指向int型变量的指针
ptr = &a     // ptr指向a变量的内存地址

Di sini alamat pembolehubah disimpan dalam penuding pembolehubah ptr.

Jenis penukaran

Pembolehubah penunjuk boleh ditukar jenis, yang sangat berguna apabila menghantar parameter fungsi atau sebarang operasi lain yang memerlukan penukaran jenis.

Contohnya:

var a int = 20
var ip *int
ip = &a

fmt.Printf("变量a的地址为：%x
", &a)
// 指针变量中存储的地址
fmt.Printf("ip 变量存储的地址：%x
", ip )
// 使用指针访问值
fmt.Printf("*ip 变量的值：%d
", *ip )

Dalam kod di atas, ditunjukkan sekali lagi bahawa alamat pembolehubah diperolehi, ip penunjuk menunjuk ke alamat a, dan kemudian nilai pembolehubah a ialah diakses melalui operator *ip.

Nilai

Melalui operator *, kita boleh mendapatkan nilai yang disimpan dalam alamat memori yang ditunjuk oleh penuding.

Contohnya:

var a int = 20   // 声明一个int型变量a
var ip *int      // 声明一个int型指针变量ip
ip = &a          // 取a的地址，将地址存储到ip中
fmt.Printf("a 变量的地址是：%x
", &a ) // 输出a的地址
fmt.Printf("ip 变量存储的地址是：%x
", ip ) // 输出ip变量中存储的地址
fmt.Printf("*ip 变量的值是：%d
", *ip ) // 输出ip变量中存储的值

Null pointer

Dalam aplikasi sebenar, kadangkala adalah mustahil untuk menentukan nilai awal yang ditunjukkan oleh penunjuk dalam kes ini, penunjuk nol lalai harus digunakan.

Dalam bahasa Go, penunjuk nol lalai diwakili oleh kata kunci nol Penunjuk nol juga dipanggil penunjuk nol. Contohnya:

var ptr *int    // 声明一个指向int型变量的指针，未赋初值
if ptr == nil {
    fmt.Printf("ptr是空指针
")
}

Dalam kod, pembolehubah penunjuk ptr diisytiharkan, tetapi tiada nilai diberikan dan nilainya adalah sifar. Pada masa ini, dengan membandingkan dengan nol, anda boleh menentukan sama ada pembolehubah penunjuk ptr ialah penunjuk nol.

Aplikasi penunjuk

Penunjuk digunakan secara meluas dalam pelbagai senario dalam bahasa Go. Di bawah, beberapa senario aplikasi biasa akan diperkenalkan.

Pass pointer parameters

Pass pointer as parameters in function calls Anda boleh menghantar alamat pembolehubah kepada fungsi panggilan, supaya nilai dalam memori yang ditunjukkan oleh penuding boleh. diubahsuai dalam fungsi , secara langsung akan mempengaruhi pembolehubah di luar fungsi.

Contohnya:

func swap (x *int, y *int) {
   var temp int
   temp = *x    // 保存x地址上的值
   *x = *y      // 将y赋值给x地址上的值
   *y = temp    // 将原来x的值赋值给y地址上的值
}

func main() {
   // 声明两个变量
   var a int = 100
   var b int = 200

   fmt.Printf("交换前，a 的值为：%d
", a )
   fmt.Printf("交换前，b 的值为：%d
", b )

   // 调用swap()函数交换值
   swap(&a, &b)

   fmt.Printf("交换后，a 的值为：%d
", a )
   fmt.Printf("交换后，b 的值为：%d
", b )
}

Dalam fungsi swap, penuding digunakan untuk menerima dua parameter yang dihantar masuk, dan operator * digunakan untuk mendapatkan nilai dalam memori yang ditunjuk oleh penunjuk. Selepas pertukaran, Berikan nilai kembali. Dalam panggilan fungsi, masukkan alamat &a dan &b, supaya pengubahsuaian di dalam fungsi akan secara langsung mempengaruhi nilai pembolehubah a dan b dalam fungsi utama.

Petunjuk pengembalian

Petunjuk pengembalian dalam fungsi juga merupakan senario aplikasi yang sangat biasa. Sama seperti mengembalikan nilai biasa, fungsi yang mengembalikan penunjuk boleh terus mengembalikan alamat penunjuk ke suatu tempat dalam program. Contohnya:

func getPtr() *int {
    i := 1
    return &i
}

func main() {
    p := getPtr()
    fmt.Println(*p)
}

Dalam fungsi getPtr, pembolehubah integer i diisytiharkan, operator & digunakan untuk mendapatkan alamat i, dan alamat ini dikembalikan. Kemudian dalam panggilan program, tetapkan nilai pulangan kepada pembolehubah penunjuk p, dan kemudian akses nilai i melalui *p.

Tatasusunan penuding

Berbeza daripada tatasusunan pembolehubah biasa, tatasusunan penuding menyimpan pembolehubah penunjuk Melalui indeks tatasusunan, anda boleh mengakses pembolehubah penunjuk yang sepadan, dan kemudian gunakan operator * untuk mendapatkan penunjuk Nilai pada alamat memori.

Contohnya:

func main() {
    a := 1
    b := 2
    c := 3

    ptrArr := [...]*int{&a, &b, &c}
    for _, ptr := range ptrArr {
        fmt.Println(*ptr)
    }
}

Dalam kod, tiga pembolehubah integer a, b, c diisytiharkan, dan kemudian tatasusunan penunjuk ptrArr diisytiharkan Gunakan... untuk mewakili panjang tatasusunan yang tidak pasti , dalam Di lokasi yang sepadan, alamat pembolehubah yang sepadan disimpan. Dalam atur cara, tatasusunan penunjuk digelung dan setiap elemen dalam tatasusunan digunakan sebagai pembolehubah penunjuk untuk mendapatkan nilai dalam alamat yang sepadan.

Ringkasan

Artikel ini terutamanya memperkenalkan konsep asas dan penggunaan penunjuk dalam bahasa Go. Menguasai penggunaan penunjuk boleh membantu pembangun mengawal penggunaan memori dengan lebih baik dan meningkatkan prestasi dan kecekapan program. Dalam projek sebenar, penunjuk digunakan dalam pelbagai senario Pembangun boleh menggunakan penunjuk dalam senario yang sesuai berdasarkan keperluan projek. Walaupun terdapat risiko tertentu dalam menggunakan penunjuk, selagi anda mengikut prinsip keselamatan data dan penggunaan piawai, anda boleh memainkan peranan sebagai penunjuk dan menulis kod dengan lebih cekap.

Atas ialah kandungan terperinci Bagaimanakah penunjuk digunakan dalam bahasa Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!