Tatasusunan penunjuk fungsi Golang dan kemahiran aplikasi penunjuk tatasusunan

Dengan pembangunan berterusan bahasa Golang, tatasusunan penuding fungsi dan penuding tatasusunan juga telah menjadi bahagian penting dalam pengaturcaraan Golang. Dalam artikel ini, kami akan membincangkan kemahiran aplikasi tatasusunan penuding dan penuding tatasusunan dalam fungsi Golang dan memberi anda beberapa kod contoh praktikal dan penjelasan berkaitan.

Konsep asas tatasusunan penunjuk Golang

Pertama sekali, mari kita fahami tatasusunan penunjuk Golang dahulu. Tatasusunan penunjuk ialah jenis data yang merupakan tatasusunan yang terdiri daripada berbilang penunjuk yang menunjuk kepada pembolehubah atau objek yang berbeza. Anda boleh menggunakan kod berikut untuk mengisytiharkan tatasusunan penunjuk:

var ptrArr [4]*int

Kod ini akan mengisytiharkan tatasusunan penunjuk dengan panjang 4, di mana setiap elemen adalah penunjuk kepada jenis int. Sudah tentu, anda juga boleh menetapkan panjang tatasusunan kepada sebarang nilai yang anda mahukan.

Dalam Golang, kita boleh menambah elemen pada tatasusunan penuding dengan cara berikut:

var p1 = new(int)
var p2 = new(int)
var p3 = new(int)
var p4 = new(int)
ptrArr := [4]*int{p1, p2, p3, p4}

Pembolehubah penuding yang dicipta melalui fungsi baharu akan memperuntukkan alamat memori dan mengembalikan penuding ke alamat itu . Oleh itu, kod di atas akan menambah empat elemen pada tatasusunan penunjuk, setiap elemen menunjuk kepada pembolehubah jenis int.

Aplikasi tatasusunan penuding

Susun atur penuding sangat berguna dalam pengaturcaraan Golang dan boleh digunakan dalam pelbagai situasi yang berbeza. Berikut ialah beberapa kes penggunaan praktikal:

1. Menggunakan tatasusunan penuding untuk menetapkan nilai kepada berbilang pembolehubah

Andaikan anda perlu menetapkan berbilang pembolehubah kepada nilai yang sama, Anda boleh menggunakan pelbagai penunjuk untuk tujuan ini. Kod berikut menunjukkan cara menggunakan tatasusunan penunjuk untuk menetapkan berbilang pembolehubah jenis int:

var a, b, c, d int
ptrArr := [4]*int{&a, &b, &c, &d}

for _, p := range ptrArr{
  *p = 8
}

fmt.Println(a, b, c, d) //将会输出 "8 8 8 8"

Dalam contoh ini, kita mula-mula mengisytiharkan empat pembolehubah jenis int dan kemudian mencipta tatasusunan penunjuk dengan setiap elemen Ia adalah semua petunjuk kepada empat pembolehubah ini. Seterusnya, kami menggunakan gelung for untuk melelaran melalui tatasusunan penunjuk ini dan tetapkan nilai yang ditunjuk oleh setiap penuding kepada 8.

2. Gunakan tatasusunan penunjuk untuk menetapkan nilai kepada pembolehubah jenis yang berbeza

Perbezaan daripada contoh sebelumnya ialah dalam contoh ini, kita perlu menetapkan dua pembolehubah jenis yang berbeza. Kod berikut menunjukkan cara menggunakan tatasusunan penunjuk untuk menetapkan pembolehubah rentetan jenis dan pembolehubah jenis int:

var i int
var j string
ptrArr := [2]interface{}{&i, &j}

for _, p := range ptrArr{
  switch t := p.(type) {
   case *int:
     *t = 5
   case *string:
     *t = "Golang"
  }
}

fmt.Println(i, j) //将会输出 "5 Golang"

Dalam contoh ini, kami menggunakan tatasusunan penunjuk panjang 2, dengan satu elemen adalah penunjuk kepada Penunjuk kepada pembolehubah jenis int, dan yang lain ialah penunjuk kepada pembolehubah jenis rentetan. Kami mengulangi melalui tatasusunan penunjuk ini melalui gelung for dan pernyataan suis, dan menetapkan nilai yang ditunjuk oleh setiap penuding kepada nilai yang sepadan.

Konsep asas penuding tatasusunan Golang

Seterusnya, mari belajar tentang penuding tatasusunan Golang. Penunjuk tatasusunan ialah penuding kepada tatasusunan Anda boleh menggunakan kod berikut untuk mengisytiharkan penuding tatasusunan:

var arrPtr *[4]int

Dalam contoh ini, kami mengisytiharkan penuding kepada tatasusunan jenis int. Penunjuk ini boleh digunakan untuk memanipulasi keseluruhan tatasusunan.

Menggunakan Penunjuk Tatasusunan

Dalam pengaturcaraan Golang, penunjuk tatasusunan boleh digunakan untuk pelbagai tugas yang berbeza. Berikut ialah beberapa contoh menggunakan penunjuk tatasusunan:

1. Melalukan tatasusunan kepada berfungsi sebagai penunjuk

Di Golang, tatasusunan dan hirisan ialah kedua-dua jenis nilai, yang bermaksud apabila anda lulus tatasusunan kepada fungsi, fungsi itu mencipta salinan tatasusunan. Jika anda ingin mengubah suai tatasusunan yang diserahkan kepada fungsi, anda perlu menggunakan penuding tatasusunan. Kod berikut menunjukkan cara untuk menghantar tatasusunan kepada fungsi menggunakan penuding tatasusunan:

func modifyArray(arr *[4]int) {
  arr[0] = 5
  arr[2] = 7
}

var arr [4]int
arrPtr := &arr
modifyArray(arrPtr)
fmt.Println(arr) //将会输出 "[5 0 7 0]"

Dalam contoh ini, kami mula-mula mengisytiharkan tatasusunan dan penuding tatasusunan. Seterusnya, kami menghantar penuding tatasusunan kepada fungsi yang dipanggil modifyArray, yang mengubah suai tatasusunan yang dihantar kepadanya. Dalam fungsi modifyArray, kita boleh mengakses tatasusunan di luar fungsi melalui penuding tatasusunan dan mengubah suainya.

2. Menggunakan penuding tatasusunan sebagai pengganti tatasusunan

Dalam sesetengah senario, penuding tatasusunan boleh menggantikan tatasusunan untuk mencapai tujuan yang sama. Kod berikut menunjukkan cara menggunakan penuding tatasusunan untuk memanipulasi tatasusunan:

arrPtr := new([4]int)
for i := 0; i < 4; i++ {
  arrPtr[i] = i + 1
}

for _, v := range arrPtr {
  fmt.Println(v)  //将会输出 "1 2 3 4"
}

Dalam contoh ini, kami menggunakan fungsi baharu untuk memperuntukkan tatasusunan baharu dan menghalakannya ke penuding tatasusunan. Kita boleh mengakses setiap elemen dalam tatasusunan melalui penuding ini, sama seperti mengakses tatasusunan biasa.

Kesimpulan

Dalam artikel ini, kami mempunyai perbincangan mendalam tentang tatasusunan penuding fungsi Golang dan teknik aplikasi penuding tatasusunan, dan juga memberikan anda beberapa kod sampel praktikal dan penjelasan berkaitan.

Tatasusunan penuding dan penuding tatasusunan ialah alat yang sangat penting dalam pengaturcaraan Golang, dan ia boleh digunakan dalam banyak senario yang berbeza. Selagi anda memahami konsep asas dan kaedah penggunaannya, anda akan lebih selesa dalam pengaturcaraan Golang.

Atas ialah kandungan terperinci Tatasusunan penunjuk fungsi Golang dan kemahiran aplikasi penunjuk tatasusunan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!