ไป - ตัวชี้

คำแนะนำใน Go นั้นง่ายและสนุกในการเรียนรู้ งานการเขียนโปรแกรม Go บางอย่างดำเนินการได้ง่ายกว่าด้วยพอยน์เตอร์และงานอื่น ๆ เช่นการโทรโดยการอ้างอิงไม่สามารถทำได้โดยไม่ใช้พอยน์เตอร์ ดังนั้นจึงจำเป็นต้องเรียนรู้คำแนะนำเพื่อเป็นโปรแกรมเมอร์ Go ที่สมบูรณ์แบบ

ดังที่คุณทราบทุกตัวแปรคือตำแหน่งหน่วยความจำและตำแหน่งหน่วยความจำทุกแห่งจะมีที่อยู่ที่กำหนดไว้ซึ่งสามารถเข้าถึงได้โดยใช้ตัวดำเนินการเครื่องหมายและ (&) ซึ่งหมายถึงที่อยู่ในหน่วยความจำ พิจารณาตัวอย่างต่อไปนี้ซึ่งจะพิมพ์ที่อยู่ของตัวแปรที่กำหนด -

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Address of a variable: 10328000

คุณจึงเข้าใจว่าที่อยู่หน่วยความจำคืออะไรและจะเข้าถึงได้อย่างไร ตอนนี้ให้เราดูว่าพอยน์เตอร์คืออะไร

ตัวชี้คืออะไร?

ก pointerเป็นตัวแปรที่มีค่าเป็นที่อยู่ของตัวแปรอื่นเช่นที่อยู่โดยตรงของตำแหน่งหน่วยความจำ เช่นเดียวกับตัวแปรหรือค่าคงที่คุณต้องประกาศตัวชี้ก่อนจึงจะสามารถใช้เพื่อจัดเก็บที่อยู่ตัวแปรได้ รูปแบบทั่วไปของการประกาศตัวแปรพอยน์เตอร์คือ -

var var_name *var-type

ที่นี่ typeเป็นประเภทฐานของตัวชี้ ต้องเป็นประเภทข้อมูล C ที่ถูกต้องและvar-nameคือชื่อของตัวแปรพอยน์เตอร์ เครื่องหมายดอกจัน * ที่คุณใช้ในการประกาศตัวชี้เป็นเครื่องหมายดอกจันเดียวกับที่คุณใช้ในการคูณ อย่างไรก็ตามในคำสั่งนี้จะใช้เครื่องหมายดอกจันเพื่อกำหนดตัวแปรเป็นตัวชี้ ต่อไปนี้เป็นการประกาศตัวชี้ที่ถูกต้อง -

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

ชนิดข้อมูลจริงของค่าของพอยน์เตอร์ทั้งหมดไม่ว่าจะเป็นจำนวนเต็มจำนวนทศนิยมหรืออื่น ๆ จะเหมือนกันเป็นเลขฐานสิบหกแบบยาวที่แสดงแอดเดรสหน่วยความจำ ข้อแตกต่างเพียงอย่างเดียวระหว่างพอยน์เตอร์ของชนิดข้อมูลที่แตกต่างกันคือชนิดข้อมูลของตัวแปรหรือค่าคงที่ที่ตัวชี้ชี้ไป

วิธีใช้พอยน์เตอร์

มีการดำเนินการที่สำคัญบางอย่างซึ่งเรามักจะดำเนินการโดยใช้พอยน์เตอร์: (ก) เรากำหนดตัวแปรพอยน์เตอร์ (b) กำหนดแอดเดรสของตัวแปรให้กับพอยน์เตอร์และ (ค) เข้าถึงค่าที่แอดเดรสที่เก็บไว้ในตัวแปรพอยน์เตอร์ .

การดำเนินการทั้งหมดนี้ดำเนินการโดยใช้ตัวดำเนินการยูนารี * ที่ส่งคืนค่าของตัวแปรที่อยู่ตามที่อยู่ที่ระบุโดยตัวถูกดำเนินการ ตัวอย่างต่อไปนี้สาธิตวิธีดำเนินการเหล่านี้ -

package main

import "fmt"

func main() {
   var a int = 20   /* actual variable declaration */
   var ip *int      /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/

   fmt.Printf("Address of a variable: %x\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

Nil Pointers ใน Go

ไปที่คอมไพเลอร์กำหนดค่า Nil ให้กับตัวแปรพอยน์เตอร์ในกรณีที่คุณไม่มีแอดเดรสที่แน่นอนที่จะกำหนด สิ่งนี้ทำได้ในช่วงเวลาของการประกาศตัวแปร ตัวชี้ที่กำหนดค่าศูนย์เรียกว่า anil ตัวชี้

ตัวชี้ศูนย์เป็นค่าคงที่โดยมีค่าเป็นศูนย์ที่กำหนดไว้ในไลบรารีมาตรฐานต่างๆ พิจารณาโปรแกรมต่อไปนี้ -

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

The value of ptr is 0

ในระบบปฏิบัติการส่วนใหญ่โปรแกรมไม่ได้รับอนุญาตให้เข้าถึงหน่วยความจำที่อยู่ 0 เนื่องจากหน่วยความจำนั้นสงวนไว้โดยระบบปฏิบัติการ อย่างไรก็ตามที่อยู่หน่วยความจำ 0 มีความสำคัญเป็นพิเศษ เป็นการส่งสัญญาณว่าตัวชี้ไม่ได้ตั้งใจให้ชี้ไปยังตำแหน่งหน่วยความจำที่สามารถเข้าถึงได้ แต่ตามแบบแผนถ้าตัวชี้มีค่าศูนย์ (ศูนย์) จะถือว่าชี้ไปที่ความว่างเปล่า

ในการตรวจหาตัวชี้ศูนย์คุณสามารถใช้คำสั่ง if ได้ดังนี้ -

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

ไปที่ตัวชี้ในรายละเอียด

พอยน์เตอร์มีแนวคิดมากมาย แต่ใช้งานง่ายและมีความสำคัญต่อการเขียนโปรแกรม Go แนวคิดของพอยน์เตอร์ต่อไปนี้ควรชัดเจนสำหรับโปรแกรมเมอร์ Go -

ซีเนียร์ No	แนวคิดและคำอธิบาย
1	ไป - อาร์เรย์ของพอยน์เตอร์ คุณสามารถกำหนดอาร์เรย์เพื่อเก็บพอยน์เตอร์ได้หลายตัว
2	ไป - ชี้ไปที่ตัวชี้ Go ช่วยให้คุณมีตัวชี้บนตัวชี้และอื่น ๆ
3	ส่งพอยน์เตอร์ไปยังฟังก์ชันใน Go การส่งผ่านอาร์กิวเมนต์โดยการอ้างอิงหรือตามที่อยู่ทั้งสองทำให้อาร์กิวเมนต์ที่ส่งผ่านสามารถเปลี่ยนแปลงได้ในฟังก์ชันการเรียกโดยฟังก์ชันที่เรียกว่า