สวัสดีและยินดีต้อนรับกลับ
ในการบรรยายนี้ ฉันต้องการพูดคุยเกี่ยวกับแนวคิดที่เรียกว่า pass by reference
เมื่อเราเริ่มพูดถึงพอยน์เตอร์ ฉันได้กล่าวถึงข้อดีอย่างหนึ่งคือ คุณไม่จำเป็นต้องใช้ตัวแปรส่วนกลางมากนัก
เพราะเมื่อคุณส่งตัวชี้ไปยังฟังก์ชัน
ฟังก์ชันสามารถใช้พารามิเตอร์นั้นได้ และเมื่อแก้ไขพารามิเตอร์นั้น ข้อมูลจะถูกแก้ไขนอกฟังก์ชัน
นี่เป็นแนวคิดที่มีคุณค่าและมีค่า
เราจะมาพูดถึงเรื่องนี้กัน นี่เป็นแนวคิดมากกว่า C จริง ๆ แล้วไม่ได้ใช้สิ่งนี้
และผมจะแสดงให้คุณเห็นถึงวิธีการและให้ตัวอย่างโดยพื้นฐานว่ามันทำงานอย่างไร
ดังนั้นจึงมีแนวคิดของการส่งต่อคุณค่า สิ่งนี้เกี่ยวข้องกับฟังก์ชั่น
เราพูดถึงการส่งข้อมูลไปยังฟังก์ชัน แต่จริงๆ แล้วข้อมูลนั้นถูกส่งผ่านในแง่ของภาษาในคอมไพเลอร์ได้อย่างไร
จึงมีแนวคิดว่าผ่านคุณค่า และนี่คือสิ่งที่เรากำลังพูดถึงจนถึงตอนนี้
เมื่อใดก็ตามที่เราเรียกใช้ฟังก์ชันนอกเหนือจากฟังก์ชัน
scanf แต่ทุกครั้งที่เราเรียกใช้ฟังก์ชันนั้น เมื่อคุณแก้ไขข้อมูลนั้นภายในฟังก์ชัน
ข้อมูลนั้นจะไม่ได้รับการแก้ไขนอกฟังก์ชัน
ดังนั้นเราจึงพูดถึงตัวแปรท้องถิ่นซึ่งเป็นแนวคิดที่ต่างออกไป
แต่เมื่อคุณส่งข้อมูลไปยังฟังก์ชัน คุณสามารถส่งข้อมูลได้สองวิธี
คุณสามารถส่งต่อด้วยค่า คุณสามารถส่งต่อโดยการอ้างอิง
C จะส่งผ่านเฉพาะค่าเท่านั้น และ java ก็ส่งผ่านด้วยค่าเช่นเดียวกัน
แต่มันจำลองผ่านการอ้างอิงเพราะคุณคัดลอกที่อยู่
ดังนั้นแม้ว่าแนวคิดนี้ผ่านการอ้างอิงไม่ได้ถูกใช้โดยเฉพาะโดย
c แต่ก็จำลองแนวคิดนี้ เพื่อทำความเข้าใจว่าการอ้างอิงหมายถึงอะไร
และเหตุใดจึงสำคัญ เราจะพูดถึงเรื่องนี้
แต่ค่าที่ส่งผ่านคือเมื่อฟังก์ชันคัดลอกค่าจริงของอาร์กิวเมนต์ลงในพารามิเตอร์ที่เป็นทางการของฟังก์ชัน
และนี่คือเหตุผลว่าทำไมถ้าคุณมีจำนวนเต็ม ทุ่น
หรือคู่ และคุณส่งผ่านสิ่งนั้นมาเป็นอาร์กิวเมนต์ของฟังก์ชัน
ตัวแปรจริงนั้นจะไม่ได้รับการแก้ไขนอกฟังก์ชันเพราะถูกคัดลอก
ดังนั้นการเปลี่ยนแปลงที่ทำกับพารามิเตอร์ภายในฟังก์ชันจึงไม่มีผลต่ออาร์กิวเมนต์
อาร์กิวเมนต์ที่ส่งผ่านจะไม่ได้รับการแก้ไข
ดังนั้นจึงเกือบจะทำหน้าที่เป็นตัวแปรในเครื่องเพราะเป็นสำเนา
สิ่งที่เกิดขึ้นจริงภายใต้ประทุนคือการคัดลอกและส่งต่อไปยังฟังก์ชัน
โปรแกรม C ใช้การเรียกตามค่าเพื่อส่งผ่านอาร์กิวเมนต์
ทุกสิ่งถูกเรียกด้วยคุณค่า ผ่านตามคุณค่า
คำเหล่านี้ใช้แทนกันได้
ดังนั้น นี่หมายความว่าโค้ดภายในฟังก์ชันไม่สามารถเปลี่ยนแปลงอาร์กิวเมนต์ที่ใช้ในการเรียกใช้ฟังก์ชันได้
ไม่มีการเปลี่ยนแปลงค่าแม้ว่าจะมีการเปลี่ยนแปลงภายในฟังก์ชัน
ดูเหมือนว่าเป็นตัวแปรท้องถิ่น
และนั่นเป็นสาเหตุว่าทำไมก่อนหน้านี้ถึงถึงจุดนี้
เมื่อคุณต้องสร้างข้อมูลทั่วโลก ถ้าคุณต้องการแบ่งปันข้อมูลจากฟังก์ชันหนึ่งไปยังฟังก์ชันถัดไป
และนี่คือวิธีการทำงานของ c
แต่จะเกิดอะไรขึ้นเมื่อคุณส่งสำเนาที่อยู่
จากนั้นมันสามารถเลียนแบบผ่านโดยการอ้างอิง
แต่นี่คือตัวอย่างวิธีที่เราใช้ pass by value ซึ่งแสดงให้เห็นแล้วว่าดีมากที่นี่
รูทีนการสลับนี้เป็นกรณีที่ใช้บ่อยในการแสดงค่าผ่านเนื่องจากสิ่งที่ทำคือสร้างอุณหภูมิและสลับพารามิเตอร์ที่อาร์กิวเมนต์ถูกส่ง
ดังนั้นถ้าเรามีฟังก์ชันที่เรียกว่า swap ที่มีจำนวนเต็มสองตัว
เราจะสร้างตัวแปร temp แบบโลคัล
ถ้าเรากำหนดพารามิเตอร์ x ให้กับ temp, temp
จะเท่ากับ x ถ้าเราบอกว่า x เท่ากับ
y, y จะเท่ากับ x ถ้าเราบอกว่า y เท่ากับอุณหภูมิ,
y จะเท่ากับอุณหภูมิ
แต่เมื่อเรียกใช้ฟังก์ชันนี้ส่งผ่านค่าเหล่านั้น
x และ y จะอยู่ภายในฟังก์ชันนี้
ตัวแปรเหล่านั้นจะไม่ถูกแก้ไขนอกฟังก์ชันนี้
และฟังก์ชันนี้แสดงให้เห็นว่ามีประโยชน์มาก เพราะเรากำหนดให้กับ
y และกำหนดให้กับ x
และ x และ y อยู่ในฟังก์ชันนี้เพราะเรากำลังส่งผ่านค่า พวกมันจะไม่ได้รับการแก้ไขนอกฟังก์ชันนี้
และนั่นเป็นสาเหตุที่เราต้องใช้ตัวแปรส่วนกลาง
แต่เป็นจำนวนเต็ม พวกมันเป็นจำนวนเต็ม x กับ y สองตัว ไม่ใช่แอดเดรส แต่เป็นจำนวนเต็มและนั่นสำคัญมาก
ดังนั้นหากเราเรียก swap
และเห็นว่ามันเป็นอย่างไร คุณจะสังเกตเห็นว่าค่าไม่เปลี่ยนแปลง
ดังนั้นหากเราสร้างตัวแปรที่เรียกว่า 100
b ด้วย 200 และเราพิมพ์ตัวแปรก่อนที่เราจะสลับ
100 และ 200 จากนั้นเราเรียกว่า swap ตัวแปรจะไม่ถูกเปลี่ยนหลังจากที่เราพิมพ์ออกมาอีกครั้ง
ลองดูสิ่งนี้ในบล็อคโค้ดและนี่จะแสดงให้เห็นการส่งผ่านค่า
นี่คือตัวอย่างของเรา เรามีรูทีนการแลกเปลี่ยนของเรา
เรากำลังสลับค่าของข้อมูลที่ส่งผ่าน x และ y
เราเรียกมันว่า 100 200
เราจะพิมพ์ออกมาก่อนที่เราจะเรียกใช้ฟังก์ชัน
เราจะพิมพ์ออกมาทีหลัง
และสิ่งที่คุณจะสังเกตเห็นคือตัวแปร a และ b ไม่เคยเปลี่ยน
และสาเหตุที่เป็นเช่นนี้ก็เพราะว่าเรากำลังก้าวผ่านคุณค่า
ดังนั้น ถ้าฉันเรียกใช้โปรแกรมนี้
เราจะเห็นได้ว่าก่อนที่จะสลับค่าของ a คือ 100 หลังจากที่คุณสลับค่าของ a เป็น 100 และมีค่าเท่ากันสำหรับ
b 200 และ 200
และเหตุผลนี้เป็นเพราะเราผ่านคุณค่า ถ้าเราส่งผ่านโดยการอ้างอิง
ตัวแปร a และ b จะเปลี่ยนไปหลังจากการเรียกสลับ
แล้วถ้าเราใช้เทคนิคเดียวกันนี้ ผ่านคุณค่า แต่เราคัดลอกพอยน์เตอร์
คุณคิดว่าจะเกิดอะไรขึ้น?
ดังนั้นพอยน์เตอร์และฟังก์ชันจึงเข้ากันได้ค่อนข้างดี
คุณสามารถส่งตัวชี้เป็นอาร์กิวเมนต์ไปยังฟังก์ชันได้
และคุณยังสามารถให้ฟังก์ชันส่งคืนตัวชี้เป็นผลลัพธ์ได้ด้วย
เราจะแสดงวิธีการทำเช่นกัน
แต่ผ่านการอ้างอิงคัดลอกที่อยู่ของอาร์กิวเมนต์ลงในพารามิเตอร์ที่เป็นทางการ
ที่อยู่ใช้เพื่อเข้าถึงอาร์กิวเมนต์จริงที่ใช้ในการโทร
สิ่งนี้หมายความว่าการเปลี่ยนแปลงที่ทำกับพารามิเตอร์ภายในฟังก์ชันส่งผลต่ออาร์กิวเมนต์ที่อยู่ในการโทร
ดังนั้นแม้ว่าในทางเทคนิคแล้วจะไม่อยู่ภายใต้ประทุนที่ส่งผ่านโดยการอ้างอิง
แต่ก็เลียนแบบหรือจำลองผ่านโดยการอ้างอิง
เรากำลังคัดลอกที่อยู่ หากคุณคัดลอกที่อยู่ คุณจะมีที่อยู่และหน่วยความจำใหม่สำหรับค่าที่อยู่นั้น
แต่ถ้าคุณพยายามกำหนดให้กับที่อยู่นั้น มันจะถูกกำหนดให้กับที่อยู่นั้น
ดังนั้นถึงแม้มันจะผ่านคุณค่า มันก็คือการคัดลอก
และถ้าคุณกำลังคัดลอกจำนวนเต็มปกติ คุณจะไม่ทำการเปลี่ยนแปลง หากคุณกำลังคัดลอกที่อยู่ ที่อยู่นั้นจะอยู่ในหน่วยความจำ
ดังนั้นเมื่อคุณทำการเปลี่ยนแปลง คุณจะต้องทำการเปลี่ยนแปลงที่อยู่นั้น
ดังนั้น ในการส่งค่าโดยการอ้างอิง
ตัวชี้อาร์กิวเมนต์จะถูกส่งไปยังฟังก์ชันเช่นเดียวกับค่าอื่นๆ
คุณต้องประกาศพารามิเตอร์ของฟังก์ชันเป็นประเภทตัวชี้ด้วยเครื่องหมายดอกจัน
การเปลี่ยนแปลงภายในฟังก์ชันจะสะท้อนให้เห็นภายนอกฟังก์ชันด้วยเช่นกัน
คุณไม่จำเป็นต้องใช้ตัวแปรส่วนกลางมากนัก
ไม่เหมือนกับการเรียกตามค่าที่การเปลี่ยนแปลงไม่สะท้อนถึงฟังก์ชันภายนอก
เรากำลังคัดลอก เรายังคงส่งผ่านค่า เป็นเพียงค่าสำเนาของที่อยู่
นี่เป็นแนวคิดที่สำคัญที่ต้องทำความเข้าใจ
เมื่อเราสร้างฟังก์ชันสลับ เราจะสร้างด้วยการประกาศภายในฟังก์ชันเป็นเครื่องหมายดอกจัน
ดาว และดาว
ที่บอกว่าฟังก์ชันนี้ใช้พอยน์เตอร์
เมื่อเรากำหนดภายในฟังก์ชันนี้ เราต้องใช้ตัวดำเนินการทางอ้อมเพื่อเลี่ยงการอ้างอิง
เพราะเราต้องการกำหนดค่า เราจะกำหนดค่าที่ x นั้น
x ชี้ไปที่อุณหภูมิ
เราจะกำหนดค่าคะแนน x ให้กับค่าที่ y ชี้ไป
จากนั้นเราจะกำหนดค่าที่ y ชี้ไปที่ ให้กับอุณหภูมิ
Temp เป็นจำนวนเต็ม เราจึงไม่ต้องอ้างอิงมัน
เมื่อเราเรียกมันด้วย
a100 และ b200 โดยส่งผ่าน a และ
b, a และ b ไม่ใช่พอยน์เตอร์ ดังนั้นเราต้องส่งผ่านแอดเดรสไปเพราะฟังก์ชันใช้พอยน์เตอร์
เมื่อใดก็ตามที่คุณมีฟังก์ชันที่ใช้พอยน์เตอร์และคุณไม่ได้ประกาศพอยน์เตอร์
คุณต้องใช้ที่อยู่ของโอเปอเรเตอร์ ซึ่งเหมือนกับวิธีที่เราใช้ scanf
แต่ตอนนี้ คุณจะสังเกตเห็นว่าเมื่อเราเรียกใช้สิ่งนี้หลังจากการเรียกเพื่อสลับตัวแปร
a และ b จะเปลี่ยนไป พวกมันจะถูกสลับ
A จะเท่ากับ 200 b จะเท่ากับ 100
ตอนนี้เรามาดูตัวอย่างนี้โดยเปลี่ยนวิธีการสลับเป็นพอยน์เตอร์ในบล็อคโค้ด
เราอยู่ในบล็อคโค้ด เราแก้ไขฟังก์ชันการสลับเพื่อใช้พอยน์เตอร์
ดังนั้นเราจึงต้องละเลยพวกเขาเมื่อเรามอบหมายพวกเขา
ตอนนี้เรายังส่งที่อยู่ของ a และ b เนื่องจากตอนนี้เป็นจำนวนเต็ม
และตอนนี้การสลับใช้ตัวชี้ เมื่อเรารันสิ่งนี้ เราจะเห็นว่าการโทรและหลังจากนี้มีการเปลี่ยนแปลง
ก่อนที่เราจะเรียก swap a เท่ากับ 100 หลังจากที่เราเรียก swap ว่า 200
ก่อนที่เราจะเรียก swap สำหรับ b มันคือ 200 ต่อไปก็ 100
ดังนั้นเราจึงสามารถเปลี่ยนค่าของตัวแปรภายในฟังก์ชันได้
เนื่องจากเรากำลังสร้างสำเนาของที่อยู่ สำคัญมาก สำคัญมาก และเป็นข้อดีอย่างหนึ่งของพอยน์เตอร์
เรามาสรุปไวยากรณ์กัน ฉันทำไปแล้ว แต่ขอดูรายละเอียดเพิ่มเติม
คุณสามารถสื่อสารข้อมูลสองประเภทเกี่ยวกับตัวแปรไปยังฟังก์ชันได้
คุณสามารถส่งค่าของ x และฟังก์ชันต้องประกาศด้วยชนิดเดียวกับ
x
เรารู้ว่า. เมื่อใดก็ตามที่เราส่งข้อมูลไปยังฟังก์ชัน
เราจะต้องมีประเภทเดียวกันเมื่อเราเรียกใช้
และที่นี่เรามี int function1 เพื่อเรียกใช้และถูกกำหนดเป็น int num
ดังนั้นเมื่อเราส่งค่าของ x ในฟังก์ชัน พวกมันจะต้องประกาศด้วยชนิดเดียวกัน
แล้วถ้าคุณต้องการเรียกใช้ที่อยู่ของ x จริงๆ มันต้องมีการกำหนดฟังก์ชันเพื่อรวมตัวชี้ไปยังประเภทที่ถูกต้อง
ดังนั้นเมื่อใดก็ตามที่คุณใช้พอยน์เตอร์ คุณต้องแน่ใจว่าหากคุณส่งข้อมูลและข้อมูลนั้นไม่ใช่พอยน์เตอร์
คุณต้องได้รับที่อยู่ของมัน
การสรุปนี้คือถ้าคุณกำหนดฟังก์ชันที่ไม่ใช้พอยน์เตอร์ คุณสามารถเรียกมันและส่งต่อข้อมูลได้
ตรวจสอบให้แน่ใจว่าไม่ใช่ตัวชี้
หากคุณมีฟังก์ชันที่ใช้ตัวชี้ดอกจัน เมื่อคุณเรียกใช้
คุณต้องเรียกใช้ด้วยตัวดำเนินการ
add หรือ sub
คุณต้องส่งที่อยู่
นั่นคือไวยากรณ์
ตอนนี้คุณสามารถตรวจสอบพารามิเตอร์ของฟังก์ชันได้โดยใช้คีย์เวิร์ดคงที่
ซึ่งบ่งชี้ว่าฟังก์ชันจะถือว่าอาร์กิวเมนต์ที่ส่งผ่านสำหรับพารามิเตอร์นี้เป็นค่าคงที่
จะมีประโยชน์ก็ต่อเมื่อพารามิเตอร์เป็นตัวชี้เท่านั้น
เพราะถ้าคุณส่งผ่านค่าและคุณไม่ส่งพอยน์เตอร์ก็ไม่สำคัญเพราะจะไม่ส่งผลต่อการเปลี่ยนแปลงภายนอกฟังก์ชันแล้วทำไมคุณถึงทำให้มันคงที่ใครจะไปสนใจว่าคุณจะเปลี่ยนมัน
.
เหตุผลเดียวที่คุณสร้างค่าคงที่ตัวชี้เป็นเพราะคุณไม่ต้องการให้ค่าฟังก์ชันภายนอกเปลี่ยนแปลง
ดังนั้น คุณสามารถใช้คีย์เวิร์ดคงที่กับพารามิเตอร์ที่เป็นพอยน์เตอร์เพื่อระบุว่าฟังก์ชันจะไม่เปลี่ยนค่าที่อาร์กิวเมนต์ชี้
สำคัญมาก.
ในตัวอย่างนี้ เรามีฟังก์ชันส่งข้อความ มันใช้ตัวชี้ข้อความ
p
เราใส่คำสำคัญคงที่ก่อนดาวถ่าน
ดังนั้นข้อความ p พารามิเตอร์ประเภทนี้จึงเป็นตัวชี้ไปยังอักขระคงที่
เป็นค่าอักขระที่คงที่ ไม่ใช่แอดเดรส
ดังนั้นในกรณีนี้ สิ่งที่เราทำคือตัวชี้ที่ถูกชี้ไปไม่สามารถเปลี่ยนแปลงได้
เราสามารถเปลี่ยนที่อยู่ได้ แต่เราไม่สามารถเปลี่ยนสิ่งที่ชี้ไปที่ค่าได้
ไวยากรณ์จะคล้ายกับเมื่อเราสร้างค่าคงที่บนพอยน์เตอร์อื่นๆ
คีย์เวิร์ดคงที่คือสิ่งแรกที่แสดง จากนั้นคุณไม่สามารถเปลี่ยนค่าได้
ตอนนี้คุณสามารถระบุตัวชี้เองว่าเป็นค่าคงที่ แต่สิ่งนี้ไม่สมเหตุสมผลเนื่องจากที่อยู่ถูกส่งผ่านตามค่า
คุณไม่สามารถเปลี่ยนตัวชี้การแสดงผลในฟังก์ชันการเรียก
นี่ก็แค่ถ้าคุณพยายามทำให้มันเปลี่ยนที่อยู่ไม่ได้
เพราะอะไรเพราะมันผ่านค่าไปแล้ว คุณกำลังสร้างตำแหน่งหน่วยความจำใหม่เพื่อเก็บที่อยู่นั้นไว้
ดังนั้นถ้าคุณเปลี่ยนแล้วใครจะสนล่ะว่าภายนอกจะไม่เปลี่ยน
คุณแค่ต้องการให้พารามิเตอร์เป็นค่าคงที่เพื่อที่คุณจะได้ไม่เปลี่ยนค่าของสิ่งที่มันชี้ไป
คุณไม่สามารถเปลี่ยนตัวชี้เดิมและฟังก์ชันการเรียกได้อยู่ดี
เพราะมันส่งผ่านโดยค่าที่ส่งผ่านการคัดลอก
คอมไพเลอร์รู้ว่าอาร์กิวเมนต์ที่เป็นตัวชี้ไปยังข้อมูลคงที่จะปลอดภัย
ดังนั้นจึงมีข้อดี คุณไม่สามารถแก้ไขค่าที่ชี้ไปโดยไม่ได้ตั้งใจได้
ดังนั้น คุณอาจทำสิ่งนี้อีกครั้งถ้าคุณไม่ต้องการให้การเปลี่ยนแปลงปรากฏที่ด้านนอกของฟังก์ชัน
หากคุณส่งตัวชี้ไปยังข้อมูลคงที่เป็นอาร์กิวเมนต์สำหรับพารามิเตอร์
พารามิเตอร์จะต้องใช้ดังที่กล่าวมา
เมื่อคุณเรียกใช้ฟังก์ชันและส่งต่อไปยังค่าคงที่ คุณจะต้องให้การประกาศฟังก์ชันใช้ตัวชี้อักขระคงที่ด้วย
เช่นเดียวกับพอยน์เตอร์อื่นๆ ที่เป็นค่าคงที่
ต้องกำหนดและกำหนดต้องตรงกับต้นแบบ
ส่งคืนพอยน์เตอร์จากฟังก์ชัน
การส่งคืนตัวชี้จากฟังก์ชันเป็นความสามารถที่ทรงพลังโดยเฉพาะ
มันให้วิธีสำหรับคุณในการคืนค่าไม่ใช่แค่ค่าเดียวแต่เป็นทั้งชุดของค่า
ข้อดีอีกอย่างหนึ่งที่ฉันพูดถึงเกี่ยวกับพอยน์เตอร์ก็คือตอนนี้คุณสามารถส่งคืนข้อมูลเพิ่มเติมจากฟังก์ชันได้แล้ว
ในอดีต คุณสามารถคืนค่าได้เพียงค่าเดียวเท่านั้น
แต่ด้วยพอยน์เตอร์เพราะพอยน์เตอร์อาจชี้ไปที่โครงสร้างที่เรายังไม่ได้พูดถึง
หรือแม้แต่สิ่งอื่น ๆ คุณสามารถคืนค่าได้หลายค่า ดังนั้นเราจึงรู้วิธีส่งพอยน์เตอร์ไปยังฟังก์ชัน
ตอนนี้ เราต้องการพูดถึงการส่งคืนพอยน์เตอร์
คุณจะต้องประกาศฟังก์ชันที่ส่งคืนตัวชี้ ดังนั้นการประกาศฟังก์ชันต้องตรงกัน
มันง่ายมากที่จะทำอย่างนั้น คุณแค่บอกว่าใช้เครื่องหมายดอกจันเมื่อคุณประกาศฟังก์ชันหรือกำหนดฟังก์ชันและมีประเภทการส่งคืนสำหรับพอยน์เตอร์นั้นที่ชี้ไป
ดังนั้นโปรดใช้ความระมัดระวังแม้ว่าจะมีอันตรายเฉพาะที่เกี่ยวข้องกับการส่งคืนตัวชี้
ใช้ตัวแปรโลคัลเพื่อหลีกเลี่ยงการรบกวนตัวแปรที่อาร์กิวเมนต์ชี้ไป
ค่อนข้างมีปัญหาเมื่อคุณส่งคืนพอยน์เตอร์ เพราะหากคุณแก้ไขตัวชี้นั้นภายในฟังก์ชันแล้วส่งคืน
อาจเป็นสิ่งที่คุณไม่ได้ตั้งใจให้ทำ
ดังนั้นให้ใช้ตัวแปรโลคัลเสมอหากคุณไม่ต้องการส่งผลกระทบกับตัวแปรที่อาร์กิวเมนต์ของคุณชี้ไป
ดังนั้นการบรรยายนี้จึงอธิบายว่าคุณสามารถส่งพอยน์เตอร์ไปยังฟังก์ชันได้อย่างไร
และคุณสามารถส่งคืนพอยน์เตอร์จากฟังก์ชันได้อย่างไร
และด้วยการใช้กลไกนี้ในการส่งตัวชี้ไปยังฟังก์ชัน
มันแสดงให้เห็นหรือเลียนแบบการส่งผ่านโดยการอ้างอิง
เนื่องจากคุณกำลังคัดลอกในที่อยู่
และเมื่อคุณคัดลอกที่อยู่ หากคุณเขียนไปยังที่อยู่นั้น คุณจะอัปเดตสิ่งที่ชี้ไปยังที่อยู่นั้น
ซึ่งหมายความว่าคุณกำลังเปลี่ยนค่าของข้อมูลภายในฟังก์ชัน
มันจะสะท้อนให้เห็นภายนอกฟังก์ชัน
เราใช้รูทีนการสลับเพื่อแสดงให้เห็นว่า
นี่เป็นแนวคิดที่ทรงพลังมาก และคุณต้องการเลียนแบบการอ้างอิง คุณสามารถใช้พอยน์เตอร์เพื่อทำสิ่งนั้นได้
และคุณต้องการทำอย่างนั้นเมื่อคุณต้องการเปลี่ยนสิ่งต่าง ๆ นอกฟังก์ชัน
ขอขอบคุณ.