สวัสดีและยินดีต้อนรับกลับ
ในการบรรยายนี้ ฉันต้องการพูดคุยเกี่ยวกับการเข้าถึงค่าที่ตัวชี้ชี้ไป
ดังนั้น จำพอยน์เตอร์ พวกเขาเก็บที่อยู่หน่วยความจำ
ที่อยู่หน่วยความจำนั้นมีค่าของบางแห่ง
ดังนั้นพอยน์เตอร์จึงชี้ไปที่ที่อยู่หน่วยความจำนั้น ฉันต้องการได้ค่าของสิ่งที่มันชี้ไป
เนื่องจากฉันจะพิมพ์ค่าของพอยน์เตอร์ที่จะเป็นที่อยู่ แต่ฉันต้องการรับที่อยู่ ฉันต้องการรับค่าของที่อยู่
ดังนั้นคุณจึงสามารถเข้าถึงค่าของที่อยู่ที่ตัวชี้ชี้ไปโดยใช้ตัวดำเนินการทางอ้อม
ตัวดำเนินการทางอ้อมคือเครื่องหมายดอกจัน
เราจึงได้เรียนรู้วิธีใช้เครื่องหมายดอกจันเพื่อประกาศตัวชี้
และเราจะใช้เครื่องหมายดอกจันเพื่อค้นหาค่าที่ตัวชี้ชี้ไป
ดังนั้นจึงเรียกอีกอย่างว่าโอเปอเรเตอร์ dereference
เนื่องจากคุณใช้มันเพื่อยกเลิกตัวชี้
ตัวอย่างเช่น หากคุณมีตัวเลขเท่ากับ 15 คุณประกาศตัวชี้ประเภท
int ชี้ไปที่ int และกำหนดที่อยู่ของตัวเลขโดยใช้เครื่องหมายและ
ตอนนี้คุณจะหาค่าของตัวชี้ที่ชี้ไปได้อย่างไร
คุณสามารถยกเลิกการอ้างอิงได้
โดยพื้นฐานแล้วคุณสามารถระบุได้ว่าค่าที่ตัวชี้กำลังชี้ไปคือค่าใดคือ
15 เพราะมันชี้ไปยังที่อยู่ของตัวเลขซึ่งก็คือ 15
ดังนั้นตัวแปรตัวชี้จึงมีที่อยู่ของหมายเลขตัวแปร
คุณสามารถใช้ค่านี้ในนิพจน์เพื่อคำนวณค่าใหม่สำหรับผลลัพธ์
สมมุติว่าเราอยากได้ผลลัพธ์เท่ากับค่าที่ตัวชี้ชี้ไปบวกห้า
คุณจะใช้เครื่องหมายดอกจันก่อนชื่อตัวชี้
ดังนั้นสิ่งที่จะทำคือโดยพื้นฐานแล้วจะบอกว่าอะไรคือตัวแปรตัวชี้ที่ชี้ไป
มันชี้ไปที่ 15 บวกห้าเข้าไป
มันคือที่อยู่ที่ตัวชี้กำลังชี้ไปที่ค่าของที่อยู่นั้น
ดังนั้นเครื่องหมายดอกจันโอเปอเรเตอร์ทางอ้อมที่คุณควรสังเกตจึงเป็นสัญลักษณ์ที่ใช้สำหรับการคูณ
และใช้เมื่อคุณประกาศประเภทตัวชี้ด้วย
ดังนั้นสิ่งนี้จึงอาจสร้างความสับสนได้มาก
คุณรู้ได้อย่างไรว่าเกิดอะไรขึ้นหรือคอมไพเลอร์ทำงานอย่างไร
มันเป็นเรื่องของบริบท ขึ้นอยู่กับเวลาที่คุณใช้เครื่องหมายดอกจันและตำแหน่งที่คุณใช้
หากคุณใช้เครื่องหมายดอกจันเมื่อคุณประกาศตัวชี้หลังจากประเภทของตัวชี้
แสดงว่ากำลังใช้การประกาศอย่างชัดเจน
หากคุณใช้เครื่องหมายดอกจันระหว่างตัวเลขสองตัว
แสดงว่ามันถูกใช้สำหรับการคูณ และหากใช้ก่อนชื่อตัวชี้ทางด้านขวามือ
เช่น หรือด้านซ้ายมือ จะเป็นการกำหนดค่าหรือเข้าถึงค่า
ดังนั้น ทั้งหมดเกี่ยวกับบริบทเมื่อคุณใช้โอเปอเรเตอร์ทางอ้อมเหล่านี้
และนั่นคือวิธีการทำงาน
นั่นคือวิธีที่คอมไพเลอร์จะตีความมัน
เมื่อใดก็ตามที่คุณเห็นในตัวอย่างนี้ ตัวชี้รูปดาว
และคุณไม่มีประเภทข้อมูลมาก่อน หรือคุณไม่มีตัวเลขสองตัวในแต่ละด้าน
แล้วคุณจะรู้ว่ามันคือตัวชี้ทางอ้อม ที่ไม่อ้างอิง
ลองมาดูตัวอย่างกัน นี่เป็นอีกตัวอย่างหนึ่งที่เราจะสร้างจำนวนเต็มเท่ากับ
10 เรากำลังจะสร้างจำนวนเต็มของประเภทชื่อ x ตัวแปรอื่นด้วย
เรากำลังเริ่มต้นนับถึง 10, x ถูกเตรียมข้อมูลเบื้องต้นเพื่อไม่มีอะไรเลย
จากนั้นเราสร้างตัวชี้ int เรารู้ว่ามันเป็นตัวชี้ int เพราะเรามีเครื่องหมายดอกจันอยู่หลังชนิดข้อมูล
แล้วเราตั้งชื่อมันว่าตัวชี้ int
ตอนนี้เราจะกำหนดที่อยู่ของการนับให้กับตัวชี้ int นั้น
เพราะอย่าลืมว่าพอยน์เตอร์มีที่อยู่เป็นค่าเท่านั้น
แต่ยังชี้ไปที่บางสิ่งด้วย
ดังนั้นเราจึงสามารถกำหนดตัวแปร x อะไรก็ได้ที่ตัวชี้ int ชี้ไป
ค่าของแอดเดรสที่อยู่ในพอยน์เตอร์คืออะไร
x จะแสดงเป็น 10 จริงๆ
10. ถ้าเราแสดงต่อไปว่า นับ เปอร์เซ็นต์
d ird x เปอร์เซ็นต์ ird นับ เท่ากับ 10, x จะเท่ากับ 10
นั่นคือวิธีที่คุณสามารถยกเลิกการอ้างอิงตัวชี้และรับค่านั้นได้ มันชี้ไปที่ถ้าคุณต้องการแสดงค่าของตัวชี้เพราะจำได้ว่าตัวชี้มีค่าในหน่วยความจำก็เป็นเพียงที่อยู่
แล้วถ้าคุณต้องการแสดงค่าพอยน์เตอร์
ซึ่งแสดงด้วยจำนวนเต็มฐานสิบหกและที่อยู่ล่ะ
คุณสามารถใช้ตัวระบุรูปแบบ เปอร์เซ็นต์ p เราเคยคุยกันเรื่องนี้มาก่อน
สิ่งนี้จะส่งออกค่าตัวชี้เป็นที่อยู่หน่วยความจำในรูปแบบเลขฐานสิบหก
ดังนั้นถ้าเราจะทำสิ่งนี้โดยที่เราประกาศหมายเลขของเรา
เราประกาศตัวชี้ของเรา เราเริ่มต้นให้เป็นโมฆะเพราะเป็นแนวปฏิบัติที่ดีที่เราต้องการทำอย่างนั้นเสมอเมื่อใดก็ตามที่คุณไม่ได้กำหนดบางสิ่งในการประกาศให้กับตัวชี้
แน่ใจว่าคุณเริ่มต้นให้เป็นโมฆะ
จากนั้นเรากำหนดตัวแปรตัวเลข 10 ของเรา
จากนั้นเรากำหนดตัวชี้ของเราไปยังที่อยู่ของตัวเลข
ค่าของเลข p จะเท่ากับแอดเดรส
ที่อยู่. ดังนั้นถ้าเราจะลองพิมพ์ออกมา เราจะใช้เปอร์เซ็นต์ p และนั่นจะเป็นค่าของที่อยู่
ถ้าเราต้องการพิมพ์สิ่งที่ชี้ไป เราต้องยกเลิกการอ้างอิงโดยใช้ตัวดำเนินการทางอ้อม
แต่เมื่อคุณพิมพ์ที่อยู่ออกไป สิ่งที่ทำคือพิมพ์ออกมาเป็นเลขฐานสิบหกและพอยน์เตอร์ใช้หน่วยความจำ
8 ไบต์ และที่อยู่จะมีเลขฐานสิบหก
16 หลัก แล้วมันทำงานอย่างไร?
ขึ้นอยู่กับว่าเครื่องของคุณรองรับที่อยู่ 64 บิตหรือ 32 บิตหรือไม่
หากเครื่องของคุณมีระบบปฏิบัติการ 64 บิต
คุณจะเห็นเลขฐานสิบหก 16 หลัก
หากเครื่องหรือระบบปฏิบัติการของคุณมีการกำหนดแอดเดรสแบบ
32 บิตเท่านั้น คุณจะเห็นเลขฐานสิบหกแสดงเป็นเลขฐานสิบหก 8 หลัก
ตอนนี้ถ้าคุณต้องการแสดงที่อยู่
คุณอาจพูดว่าอะไรคือความแตกต่างเนื่องจากตัวชี้มีค่า
แต่คุณยังสามารถแสดงที่อยู่ด้วยที่อยู่ของโอเปอเรเตอร์
ในตัวอย่างนี้ เราต้องการแสดงที่อยู่ของตัวเลข
ตัวเลขไม่ใช่ตัวชี้ ตัวเลขเป็นเพียงจำนวนเต็ม
หากเราต้องการได้ที่อยู่นั้น เราใช้เครื่องหมายและ
หากเราต้องการแสดงที่อยู่นั้น คุณก็แค่ใช้เปอร์เซ็นต์ p อีกครั้ง
คุณเพียงแค่ใช้เครื่องหมายและ
ดังนั้นถ้าเราใส่เครื่องหมายแอมเพอร์แซนด์ด้วยตัวแปรพอยน์เตอร์
เราจะแสดงแอดเดรสของพอยน์เตอร์นั้นจริง
ๆ ไม่ใช่ค่าของจุด จำที่อยู่ของตัวชี้เป็นที่อยู่บางส่วนในหน่วยความจำ
ค่าตัวชี้คือที่อยู่ที่ชี้ไป
และคุณค่าที่มันชี้ไปนั้นอยู่ที่อื่นในความทรงจำ
ดังนั้นจงจำภาพประกอบที่เราแสดงให้เห็นว่าตัวชี้ทำงานอย่างไร
เมื่อคุณประกาศพอยน์เตอร์ ตัวชี้จะสร้างหน่วยความจำสำหรับตัวชี้นั้น
8 ไบต์
ค่าของตัวชี้นั้นเป็นที่อยู่
แล้วสิ่งที่ตัวชี้ชี้ไปก็คือค่า
ซึ่งมักจะเป็นประเภทที่คุณระบุ
แต่จำไว้ว่า มันมีสามส่วนจริงๆ
หากคุณต้องการพิมพ์ที่อยู่หมายเลข p คุณจะต้องใช้เครื่องหมายและอีกครั้ง
นั่นจะเป็นที่อยู่ของตัวชี้ที่แท้จริง
และคุณจะต้องใช้ดาวที่ว่างเปล่าเพื่อเลี่ยงคำเตือน
ดังนั้น โปรดจำไว้ว่า ตัวชี้เองมีที่อยู่ เช่นเดียวกับตัวแปรอื่นๆ ตัวชี้จะได้รับการจัดสรรเมื่อคุณประกาศ
คุณใช้เปอร์เซ็นต์ p เป็นตัวระบุการแปลงเพื่อแสดงที่อยู่
คุณใช้เครื่องหมายและที่อยู่ของตัวดำเนินการเพื่ออ้างอิงที่อยู่ที่ตัวแปรหมายเลข
p อยู่
นั่นคือที่อยู่ของตัวชี้ อีกครั้ง ตัวชี้มีค่าของที่อยู่
cast a void คือการป้องกันคำเตือนจากคอมไพเลอร์ โดยเฉพาะอย่างยิ่ง
เปอร์เซ็นต์ p คุณสมบัติคาดว่าค่าจะเป็นประเภทพอยน์เตอร์บางประเภท
แต่ประเภทของเครื่องหมายและตัวเลขเป็นตัวชี้ไปยังตัวชี้ของมัน
ดังนั้นคุณต้องโยนมัน
การแสดงจำนวนไบต์ที่ตัวชี้กำลังใช้อยู่
อีกวิธีในการรับข้อมูลเกี่ยวกับตัวชี้
ที่นี่คุณสามารถใช้ตัวดำเนินการ sizeof เราได้เรียนรู้เกี่ยวกับตัวดำเนินการ
sizeof เพื่อแสดงไบต์ประเภทข้อมูลต่างๆ คุณสามารถทำสิ่งเดียวกันกับตัวชี้
บนเครื่องที่ฉันใช้อยู่ เครื่องนี้จะกินพื้นที่ 8 ไบต์
และที่อยู่เครื่องมี 64 บิตเพราะเป็นระบบปฏิบัติการ
64 บิต
และคุณอาจได้รับคำเตือนคอมไพเลอร์เมื่อใช้ sizeof ด้วยวิธีนี้ sizet เป็นประเภทจำนวนเต็มที่กำหนดการใช้งาน
เพื่อป้องกันคำเตือน คุณสามารถส่งอาร์กิวเมนต์เป็น int ประเภทนี้ได้
สิ่งที่คุณจะทำคือคุณจะบอกว่า p number size, เปอร์เซ็นต์ d bytes
และคุณจะบอกว่า int, โยนเป็นนิ้วของเลข p
นั่นจะทำให้คุณได้ขนาดของพอยน์เตอร์ในหน่วยความจำ ขนาดของพอยน์เตอร์ของแอดเดรสนั้น
ซึ่งก็คือแปดไบต์ในระบบส่วนใหญ่
เพราะนั่นเป็นแค่ที่อยู่
ตัวอย่างอื่นที่นี่ นี่จะแสดงให้เห็นหลายอย่าง
และเราจะเรียกใช้ตัวอย่างนี้เพื่อแสดงผลลัพธ์
แต่ก่อนที่เราจะใช้งาน ฉันต้องการอธิบายเล็กน้อยว่าเกิดอะไรขึ้นที่นี่ เรามีเลขที่จดแจ้ง
เรามีพอยน์เตอร์ที่ตั้งค่าเริ่มต้นเป็นโมฆะ
เราตั้งค่าตัวเลขเป็น 10
แล้วสิ่งที่เราต้องการทำคือ เราต้องการพิมพ์ที่อยู่ของเลขจำนวนเต็มออกมา
และเราต้องการพิมพ์ค่าของตัวเลข อย่างง่าย ๆ โดยใช้ที่อยู่ของตัวดำเนินการ
และจากนั้นก็แค่ตัวแปร
เมื่อเราทำที่อยู่ของโอเปอเรเตอร์ เราทำเปอร์เซ็นต์ p
จากนั้นเราจะกำหนดที่อยู่ของหมายเลขให้กับตัวชี้ของเรา
จากนั้นเราจะพิมพ์ข้อมูลพอยน์เตอร์ออกมา
เราต้องการส่งออกที่อยู่ของตัวชี้เอง
เราสามารถใช้เปอร์เซ็นต์ p เครื่องหมายดาวเป็นโมฆะได้
เราต้องการดูจำนวนไบต์ที่ตัวชี้มีในหน่วยความจำ เราสามารถพูด sizeof
เราต้องการดูค่าจริงของตัวชี้ซึ่งเป็นที่อยู่
เราสามารถพูดเลข
p โดยไม่มีข้อมูลเพิ่มเติม แล้วเราก็ใช้เปอร์เซ็นต์ p
หากเราต้องการเห็นค่าที่พอยน์เตอร์ชี้ไป
ค่าที่แอดเดรส จากนั้นเราจะทำการดาว p ตัวเลข
เราใช้ตัวดำเนินการทางอ้อม
และเรารู้ว่าเลข p ชี้ไปที่ a ดังนั้นเราสามารถบอกเปอร์เซ็นต์ d ได้
ลองมาดูตัวอย่างนี้ในบล็อคโค้ดเพื่อดูว่ามันแสดงผลอย่างไร
สิ่งที่เราจะได้เห็นคือเลขฐานสิบหกสำหรับที่อยู่ทุกครั้งที่เราแสดงที่อยู่
และเราจะเห็นค่าในกรณีอื่นๆ
ดังนั้นสิ่งนี้ควรดูคุ้นเคย นี่เป็นเพียงโปรแกรมที่แสดงวิธีเข้าถึงส่วนต่างๆ
ของพอยน์เตอร์
อีกครั้ง เรามีประเภทข้อมูลตัวเลขปกติ และเรามีตัวชี้
เราเริ่มต้นให้เป็นโมฆะ
อันดับแรกเราจะแสดงหมายเลขของเรา ซึ่งก็คือ 10 นี่จะแสดงที่อยู่ของตัวเลข
แล้วแสดงค่าของตัวเลขในบรรทัดที่ 10 และ 11
จากนั้นเราจะกำหนดตัวชี้ที่อยู่ของหมายเลข
หากเราต้องการดูที่อยู่จริงของพอยน์เตอร์ เราก็แค่ใช้เครื่องหมายและ ที่อยู่ของโอเปอเรเตอร์
และเราแคสต์ให้ดาวเป็นโมฆะ
เราใช้เปอร์เซ็นต์ p
หากเราต้องการดูจำนวนไบต์ที่พอยน์เตอร์อยู่ในหน่วยความจำ เราทำเปอร์เซ็นต์ d sizeof
หากเราต้องการดูที่อยู่เป็นค่าของตัวชี้ถั่วลิสง เราทำเปอร์เซ็นต์
p และเราก็แค่บอกว่าหมายเลข p เพราะหมายเลข p คือที่อยู่
ถ้าเราต้องการดูว่าพอยน์เตอร์ชี้ไปที่อะไรด้วยค่าของแอดเดรสที่อยู่ในค่าของพอยน์เตอร์
เราก็แค่พูดว่า เครื่องหมายดอกจัน p แทนค่านั้น ตัวดำเนินการทางอ้อม
ลองทำสิ่งนี้กัน
เมื่อฉันรันสิ่งนี้ คุณจะเห็นสองสิ่งแรกที่พิมพ์ออกมา
ที่อยู่ของตัวเลขซึ่งอยู่ในบรรทัดที่หก
และนั่นคือเลขฐานสิบหก 0060ff0c
และนี่กำลังรันโปรแกรม 32 บิตอยู่ คุณจึงเห็นว่ามันมีแค่ 8 บิตเท่านั้น
ตัวแปรตัวเลขซึ่งก็คือ 10
จากนั้นเราพิมพ์ที่อยู่ของตัวชี้จริงไปยังหน่วยความจำที่จัดสรร
ที่อยู่ต่างจากตัวเลข
เพราะนี่คือที่อยู่ที่จัดสรรสำหรับตัวชี้
ขนาดตัวเลขพอยน์เตอร์คือ 4 ไบต์ ซึ่งหมายความว่าเป็นการกำหนดแอดเดรสแบบ
32 บิต
ค่าของพอยน์เตอร์ซึ่งเป็นที่อยู่ของตัวเลขควรเหมือนกันและเป็น
0060ff0c
และคุณเห็นว่าคุณสามารถรับที่อยู่ของตัวเลขได้โดยใช้ชื่อ
ตัวชี้ที่มีเปอร์เซ็นต์ p
เราเห็นขนาดของตัวดำเนินการ 4 ไบต์
ถ้าคุณต้องการได้ค่าที่ p ชี้ไปที่ 10 คุณต้องยกเลิกการอ้างอิงโดยใช้ตัวดำเนินการทางอ้อม
และคุณเห็นว่ามันถูกพิมพ์ 10
แต่คุณเห็นว่าคุณใช้เปอร์เซ็นต์ p ทุกครั้งที่คุณแสดงที่อยู่
ให้ใช้เปอร์เซ็นต์ e เมื่อคุณแสดงค่าของตัวชี้จำนวนเต็มหรือจำนวนไบต์
นี่คือไวยากรณ์พื้นฐานของการเข้าถึงค่าพอยน์เตอร์
ที่อยู่ของตัวชี้, เครื่องหมาย,
ค่าที่จุดนั้นชี้ไป, เพียงชื่อของตัวแปรและค่าของตัวชี้เองนั้นเป็นเพียงชื่อของตัวแปร,
จากนั้นค่าที่ตัวชี้ชี้ไปเพื่อใช้ตัวดำเนินการทางอ้อม
ขอขอบคุณ. หวังว่านี่จะช่วยได้ ศึกษาสิ่งนี้ เรียกใช้สิ่งนี้