Perbezaan antara pembolehubah dan penunjuk dalam bahasa Go: analisis dari perspektif praktikal

Lihat perbezaan antara pembolehubah dan penunjuk dalam bahasa Go dari perspektif praktikal

Pengenalan:
Pembolehubah dan penunjuk ialah konsep yang sangat penting dalam bahasa Go dan sering digunakan dalam pembangunan sebenar. Artikel ini akan bermula dari perspektif praktikal dan menggunakan contoh kod khusus untuk memperkenalkan perbezaan antara pembolehubah dan penunjuk serta meneroka senario penggunaannya dalam bahasa Go.

1. Pembolehubah
Dalam bahasa Go, pembolehubah ialah unit asas untuk menyimpan data dalam ingatan. Ramai pemula sudah sangat mengenali konsep pembolehubah, jadi saya akan memperkenalkan secara ringkas pengisytiharan dan penggunaan pembolehubah, dan kemudian memberi tumpuan kepada mekanisme penghantaran berubah.

1.1 Pengisytiharan dan penggunaan pembolehubah
Dalam bahasa Go, kita boleh mengisytiharkan pembolehubah melalui kata kunci var, contohnya:

var num int    // 声明了一个整型变量num
num = 10    // 赋值
fmt.Println(num)    // 输出10

Selain menggunakan kata kunci var, kita juga boleh menggunakan pengisytiharan pembolehubah pendek untuk mengisytiharkan pembolehubah, untuk contoh:

num := 10    // 声明并初始化一个整型变量num
fmt.Println(num)    // 输出10

Kaedah ini lebih ringkas dan boleh menghilangkan kata kunci var.

1.2 Mekanisme hantaran pembolehubah
Dalam bahasa Go, terdapat dua cara untuk lulus pembolehubah: hantaran nilai dan hantaran rujukan.

Pengalihan nilai merujuk kepada menyalin nilai parameter sebenar kepada parameter formal semasa panggilan fungsi Pengubahsuaian kepada parameter formal dalam fungsi tidak akan menjejaskan nilai parameter sebenar. Contohnya:

func change(num int) {
    num = 20    // 修改形式参数的值
}
num := 10    // 声明并初始化一个整型变量num
change(num)    // 调用函数change
fmt.Println(num)    // 输出10

Anda boleh melihat bahawa walaupun nilai parameter formal diubah suai dalam fungsi perubahan, ia tidak menjejaskan nilai parameter sebenar.

Melalui rujukan merujuk kepada menghantar rujukan parameter sebenar kepada parameter formal semasa panggilan fungsi Pengubahsuaian kepada parameter formal dalam fungsi akan menjejaskan nilai parameter sebenar. Dalam bahasa Go, penunjuk digunakan untuk melaksanakan hantaran rujukan. Kami akan membincangkan penggunaan penunjuk secara terperinci dalam bahagian seterusnya.

2. Penunjuk
Dalam bahasa Go, penunjuk ialah pembolehubah yang menyimpan alamat memori pembolehubah lain. Melalui penunjuk, kita boleh mengakses dan mengubah suai nilai pembolehubah secara tidak langsung. Di bawah ini kita akan membincangkan penggunaan penunjuk dari dua aspek: pengisytiharan dan penggunaan penunjuk dan mekanisme hantar penunjuk.

2.1 Pengisytiharan dan penggunaan penunjuk
Dalam bahasa Go, kita boleh menggunakan simbol * untuk mengisytiharkan pembolehubah penunjuk, contohnya:

var ptr *int    // 声明一个指向整型变量的指针ptr
num := 10    // 声明并初始化一个整型变量num
ptr = &num    // 将num的地址赋值给ptr
fmt.Println(*ptr)    // 输出10，*ptr表示访问指针指向的值

Melalui *ptr kita boleh mengakses nilai yang ditunjukkan oleh penunjuk dan juga boleh mengubah suainya.

2.2 Mekanisme hantaran penunjuk
Dalam bahasa Go, hantaran penunjuk boleh merealisasikan hantaran rujukan, supaya pengubahsuaian fungsi pembolehubah boleh menjejaskan nilai di luar fungsi. Contohnya:

func change(ptr *int) {
    *ptr = 20    // 修改指针指向的值
}
num := 10    // 声明并初始化一个整型变量num
change(&num)    // 调用函数change
fmt.Println(num)    // 输出20

Anda boleh melihat bahawa melalui hantaran penunjuk, kami mengubah suai nilai yang ditunjukkan oleh penunjuk dalam fungsi perubahan, sekali gus menjejaskan nilai di luar fungsi.

3. Senario penggunaan pembolehubah dan penunjuk
Dalam pembangunan sebenar, kita perlu memilih untuk menggunakan pembolehubah atau penunjuk mengikut keperluan yang berbeza. Contoh khusus diberikan di bawah untuk menggambarkan perkara ini.

Katakan kita sedang membangunkan sistem pengurusan pelajar, dan setiap pelajar mengandungi dua sifat: nama dan umur. Kami mentakrifkan struktur untuk mewakili pelajar:

type Student struct {
    Name string
    Age int
}

Dalam fungsi menambah pelajar, kita perlu menghantar objek pelajar sebagai parameter. Jika lulus nilai digunakan, salinan objek pelajar akan disalin setiap kali fungsi tambah pelajar dipanggil, yang meningkatkan memori dan overhed prestasi. Oleh itu, dalam kes ini, kita boleh mempertimbangkan untuk menggunakan penunjuk untuk menghantar objek pelajar, kodnya adalah seperti berikut:

func addStudent(student *Student) {
    // ...
}

Dengan menggunakan penunjuk, kita boleh mengubah suai secara langsung nilai objek pelajar tanpa operasi salinan tambahan.

Kesimpulan:
Melalui contoh dan perbincangan di atas, kita boleh membuat kesimpulan berikut:

• Pembolehubah ialah unit asas untuk menyimpan data dalam ingatan, dan penunjuk ialah pembolehubah yang menyimpan alamat memori pembolehubah lain.
• Terdapat dua cara untuk lulus pembolehubah, lulus nilai dan lulus rujukan. Lulus melalui rujukan boleh dicapai melalui penunjuk.
• Dalam pembangunan sebenar, kita perlu memilih untuk menggunakan pembolehubah atau penunjuk mengikut keperluan.

Akhir sekali, perlu diingatkan bahawa apabila menggunakan penunjuk, anda perlu memberi perhatian sama ada pembolehubah penunjuk kosong dan sama ada memori yang ditunjuk dilepaskan, untuk mengelakkan ralat.

Atas ialah kandungan terperinci Perbezaan antara pembolehubah dan penunjuk dalam bahasa Go: analisis dari perspektif praktikal. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!