golang menukar penunjuk menunjuk

Golang ialah bahasa pengaturcaraan sumber terbuka yang cekap, berskala dan mudah dipelajari Ia digunakan secara meluas dalam aplikasi rangkaian, sistem teragih, pengkomputeran awan, kecerdasan buatan dan bidang lain.

Di Golang, penunjuk ialah jenis data yang sangat biasa Ia digunakan untuk menyimpan alamat pembolehubah dalam ingatan, membenarkan atur cara mengakses dan mengubah suai nilai pembolehubah. Penunjuk di Golang boleh mendapatkan alamat pembolehubah melalui operator &, dan secara tidak langsung mengakses nilai pembolehubah menggunakan operator *.

Walau bagaimanapun, dalam beberapa kes, kita mungkin perlu menukar penunjuk yang menunjuk dari alamat satu pembolehubah kepada alamat pembolehubah lain semasa program sedang berjalan. Ini biasanya berlaku dalam program yang melibatkan memori yang diperuntukkan secara dinamik atau operasi struktur data. Dalam artikel ini, kami akan meneroka cara menukar penunjuk penunjuk di Golang.

Penugasan penunjuk

Mula-mula, mari kita lihat contoh mudah untuk menunjukkan cara menggunakan penunjuk untuk menukar nilai pembolehubah.

package main
  
import "fmt"
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var p *int           // 声明一个整型指针p
  
    p = &a               // 将指针p指向变量a的地址
    *p = 20              // 通过指针p，修改a的值为20
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
}

Dalam kod di atas, kami mengisytiharkan pembolehubah integer a dan memulakannya kepada 10. Pada masa yang sama, penunjuk p yang menunjuk kepada integer diisytiharkan dan dihalakan ke alamat pembolehubah a melalui operator &. Seterusnya, kami menggunakan *p untuk mendapatkan nilai pembolehubah yang ditunjuk oleh penunjuk p dan mengubah suainya kepada 20, dengan itu menukar nilai pembolehubah a.

Pengalihan semula penunjuk

Dalam contoh di atas, kami mengubah suai nilai pembolehubah a melalui penunjuk p, tetapi tidak mengubah penunjuk penunjuk p itu sendiri. Sekarang, mari kita lihat cara untuk mengubah hala penuding supaya ia menunjuk ke alamat pembolehubah lain.

package main
  
import "fmt"
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p *int           // 声明一个整型指针p
  
    p = &a               // 将指针p指向变量a的地址
    p = &b               // 将指针p重定向为变量b的地址
  
    fmt.Println("a = ", a) // 输出a的值，结果为10
    fmt.Println("b = ", b) // 输出b的值，结果为20
    fmt.Println("*p = ", *p) // 输出*p所指向变量的值，结果为20
}

Dalam kod di atas, kami mengisytiharkan dua pembolehubah integer a dan b dan memulakannya masing-masing kepada 10 dan 20. Pada masa yang sama, penunjuk p yang menunjuk kepada integer diisytiharkan. Seterusnya, kami menggunakan &p untuk menghalakan penuding p ke alamat pembolehubah a, dan kemudian mengalihkannya ke alamat pembolehubah b.

Apabila kita mengeluarkan nilai a dan b, kita dapati nilainya tidak berubah, dan melalui *p kita boleh mengakses nilai pembolehubah b, iaitu 20.

Pertukaran penunjuk

Pertukaran penunjuk merujuk kepada pertukaran alamat pembolehubah yang ditunjuk oleh dua penunjuk untuk mencapai tujuan pertukaran nilai pembolehubah. Dalam bahagian ini, kami akan memperkenalkan dua kaedah untuk melaksanakan pertukaran penunjuk.

Kaedah 1: Tukar melalui pembolehubah sementara

package main
  
import "fmt"
  
func swap(a, b *int) {
    var temp int        // 定义一个临时变量temp
    temp = *a
    *a = *b
    *b = temp
}
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p1 *int = &a      // 声明一个指向变量a的指针p1
    var p2 *int = &b      // 声明一个指向变量b的指针p2
  
    swap(p1, p2)          // 交换指针p1和p2所指向变量的值
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
    fmt.Println("b = ", b) // 输出b的值，结果为10
}

Dalam kod di atas, kami mentakrifkan fungsi swap yang menerima dua penunjuk kepada jenis int. Dalam fungsi ini, kami mentakrifkan temp pembolehubah sementara untuk menyimpan nilai pembolehubah yang ditunjuk oleh salah satu penunjuk. Kemudian, kami menukar nilai pembolehubah melalui penunjuk, dan akhirnya menyedari pertukaran penunjuk.

Kaedah 2: Tukar melalui penuding ke penuding

package main
  
import "fmt"
  
func swap(a **int, b **int) {
    var temp *int         
    temp = *a
    *a = *b
    *b = temp
}
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p1 *int = &a      // 声明一个指向变量a的指针p1
    var p2 *int = &b      // 声明一个指向变量b的指针p2
  
    swap(&p1, &p2)        // 交换指针p1和p2的指向
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
    fmt.Println("b = ", b) // 输出b的值，结果为10
}

Dalam kod di atas, kami mengubah suai tandatangan fungsi swap supaya ia menerima dua penuding kepada penuding. Dengan cara ini, dalam fungsi swap, kita boleh menukar penunjuk kedua-dua penunjuk ini, dengan itu merealisasikan pertukaran penunjuk.

Ringkasan

Artikel ini terutamanya memperkenalkan kaedah menukar penunjuk penunjuk di Golang. Melalui penjelasan artikel ini, kita boleh memahami cara menggunakan penunjuk untuk menukar nilai pembolehubah, mengalihkan penunjuk, dan menukar nilai pembolehubah yang ditunjuk oleh penunjuk.

Kita perlu berhati-hati apabila menggunakan penunjuk, kerana penggunaan penunjuk yang salah boleh menyebabkan ranap program atau kerosakan data. Oleh itu, kita mesti membaca kod dengan teliti dan sentiasa menggunakan penunjuk dengan berhati-hati.

Atas ialah kandungan terperinci golang menukar penunjuk menunjuk. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!