สวัสดีและยินดีต้อนรับกลับ ในการบรรยายนี้ ฉันต้องการให้การสาธิตสำหรับความท้าทายครั้งก่อนของเราซึ่งก็คือการทำความเข้าใจผ่านโดยการอ้างอิง
การมีพารามิเตอร์ภายในฟังก์ชันจะใช้ตัวชี้
มาสร้างโครงการใหม่กันเถอะ เราจะเรียกสิ่งนี้ว่าพอยน์เตอร์ผ่านการอ้างอิง
เพราะนั่นคือสิ่งที่มันแสดงให้เห็น สิ่งพื้นฐานที่นี่ โปรเจ็กต์ใหม่
แอปพลิเคชันคอนโซล c
ค่อนข้างตรงไปตรงมาที่นี่
ให้เรียกตัวชี้ขีดล่างนี้ว่าผ่านโดยการอ้างอิง
อีกครั้ง เป็นการสาธิตว่าเราสามารถใช้พารามิเตอร์ภายในฟังก์ชันเพื่อส่งข้อมูลได้อย่างไร
และข้อมูลนั้นจะถูกแก้ไขภายนอกฟังก์ชันอย่างไร
อย่างแรกที่เราจะทำคือ เราจะสร้างการประกาศฟังก์ชันของเรา ต้นแบบฟังก์ชันของเรา
การทำเช่นนี้เป็นสิ่งที่ดีเสมอเพื่อให้คุณสามารถโทรไปที่ใดก็ได้ในโปรแกรมของคุณ
เราจะเรียกมันว่าสี่เหลี่ยม
สิ่งสำคัญในการประกาศฟังก์ชันนี้คือ จะใช้ตัวชี้
มันจะใช้ตัวชี้จุดสิ้นสุด เราแค่จะบอกว่า int star แล้วคุณตั้งชื่ออะไรก็ได้ตามต้องการ
แล้วลงท้ายด้วยเครื่องหมายอัฒภาค
และหน้าที่หลักของเรา อย่างแรกที่เราจะทำคือ
เราจะสร้างตัวแปรจำนวนเต็มปกติ แล้วเราจะบอกว่า
int num แล้วเราจะบอกว่าฮาร์ดโค้ดเป็น 9
และสิ่งที่เราจะทำคือเราจะเรียกฟังก์ชันกำลังสองของเรา
ฟังก์ชันสแควร์ของเราจะไม่ส่งคืนข้อมูลใดๆ มันจะถือเป็นโมฆะ
เราต้องส่งที่อยู่ตอนนี้เพราะฟังก์ชันกำลังสองของเราในบรรทัดที่ 4 กำลังใช้ตัวชี้อยู่
เราไม่สามารถส่ง num ได้ เราจะต้องส่งที่อยู่ของ num แล้วเราจะลงท้ายด้วยเครื่องหมายอัฒภาค
ดังนั้นเราจึงเรียกใช้ฟังก์ชันโดยใช้ชื่อฟังก์ชันแล้วส่งที่อยู่ของตัวแปร
เพราะตัวแปรในบรรทัดที่แปดไม่ใช่ตัวชี้
จากนั้นเราก็สามารถพิมพ์ค่าของ num ออกมาได้
และอีกครั้ง สิ่งที่คุณจะสังเกตเห็นในที่นี้คือ เพราะเรากำลังส่งที่อยู่
ถ้าเราเปลี่ยนข้อมูลในฟังก์ชันเองสำหรับตัวแปรนั้น มันจะเปลี่ยนแปลงไปจากภายนอก
ตรงนี้
เราจะบอกว่ากำลังสองของจำนวนที่กำหนดคือ และมันบอกว่า เปอร์เซ็นต์
d เราจะเพิ่มการป้อนบรรทัด แล้วเราจะพิมพ์
num และ num จะไม่ใช่ 9
,ฉันจะบอกคุณมาก
แล้วเราจะคืนค่า 0 สำหรับฟังก์ชันปกติของเรา
ดังนั้นตอนนี้เราต้องนำฟังก์ชันไปใช้จริง กำหนดมัน
นิยามมัน ผมจะพูดว่า void square
เรารู้ว่าต้องใช้ตัวชี้จำนวนเต็ม, ผมจะบอกว่า int star x
และตอนนี้เราต้องการแค่คูณมันด้วยตัวมันเอง
แต่เราต้องการให้แน่ใจว่าเราจะไม่เปลี่ยนที่อยู่
สิ่งที่เราสามารถทำได้ที่นี่คือเราสามารถทำให้นี่เป็นค่าคงที่ได้
แต่คุณต้องการใส่ค่าคงที่หลังประเภทข้อมูลเพราะเราไม่ต้องการเปลี่ยนค่าของสิ่งที่
x เป็นหรือที่อยู่ของสิ่งที่มันชี้ไป เราสามารถพูดได้ว่าค่าคงที่ int
ถ้าเราไม่ต้องการเปลี่ยนค่าของ
x เราก็บอกว่าค่าคงที่ แต่เราอยากเปลี่ยนค่าของ x เราจะยกกำลังสองมันเอง
ในการยกกำลังสองมันเอง อย่างแรกเลย สิ่งที่เราอยากเปลี่ยนคือค่าสูงสุดของ
x เราเลยต้องใช้ตัวดำเนินการทางอ้อม
เราต้องยกเลิกการอ้างอิงด้วยเครื่องหมายดอกจัน
แล้วเราจะบอกว่าเท่ากับ เราไม่อยากทำ
x คูณ x เพราะนั่นจะคูณที่อยู่ X เป็นตัวชี้ เราไม่ได้ต้องการแค่ค่าของ
x เราต้องการได้ค่าของสิ่งที่ x ชี้ไป
เหมือนเดิม เราต้องเลิกอ้างอิงมัน
แล้วเราจะคูณมันด้วยตัวมันเอง เราจะยกเลิกการอ้างอิงมันสองครั้ง
อาจเป็นความคิดที่ดีที่จะใส่สิ่งนี้ในวงเล็บเพื่อให้เข้าใจได้ง่ายว่าเกิดอะไรขึ้นที่นี่
คุณกำลังถอดการอ้างอิงตัวชี้ รับค่าของมันแล้วคูณด้วยค่าของมัน
จากนั้นคุณแค่บวกเครื่องหมายอัฒภาค นั่นคือทั้งหมดที่คุณต้องทำ
เมื่อเรารันโปรแกรมนี้
มันจะพิมพ์ออกมาเป็น 81
มันจะพิมพ์ค่าของ num นัมกำลังจะเปลี่ยนในจตุรัสเพราะเรากำลังส่งที่อยู่ไปที่นั่น
เราไม่สามารถเปลี่ยนค่าของตัวชี้ได้ ดังนั้นเราจึงมีค่าคงที่หลังประเภท
ในที่นี้เราพูดว่า build และดูเหมือนว่าเราไม่ได้เปลี่ยนการประกาศ
และตอนนี้เราแค่ต้องการให้แน่ใจว่าทุกอย่างถูกต้อง
หากคุณต้องการให้ตัวชี้คงที่ คุณต้องวางไว้หลังเครื่องหมายดอกจัน
ดังนั้นค่าคงที่เริ่มต้นของ
int หมายความว่าคุณไม่สามารถเปลี่ยนค่าของ
x ซึ่งเป็นที่อยู่ของ num
หากเราใส่ const ก่อน int หรือหลังอินพุตก่อนเครื่องหมายดอกจัน
แสดงว่าคุณไม่สามารถเปลี่ยนค่าของสิ่งที่ตัวชี้ชี้ไป
ตอนนี้เมื่อเรารันสิ่งนี้ เราควรเห็นเป็นเอาต์พุต 81
อีกครั้ง สิ่งนี้บอกเราว่าเราแก้ไขข้อมูล
ตัวแปรนี้
ตัวแปรโลคัล num นี้ถูกแก้ไขภายในฟังก์ชันและค่าของมันเปลี่ยนไป
นั่นไม่ปกติ เราไม่ได้เรียนรู้แนวคิดนั้นมาจนถึงตอนนี้ ที่ผ่านโดยการอ้างอิง
แต่สิ่งที่เกิดขึ้นคือคุณกำลังส่งสำเนาที่อยู่
นั่นเป็นสาเหตุที่ซ้ำซ้อนจริงๆ เราไม่ต้องการค่าคงที่ด้วยซ้ำ เพราะถึงแม้เราจะเปลี่ยนค่าของพอยน์เตอร์
มันคือสำเนาของค่าของพอยน์เตอร์ ดังนั้นคุณไม่จำเป็นต้องทำอย่างนั้นจริงๆ
ตอนนี้ถ้าเราไม่ต้องการใช้หมายเลขที่มีอยู่ เราสามารถสร้างพอยน์เตอร์ได้ เราก็แค่ต้องจัดสรรหน่วยความจำสำหรับหมายเลขนั้น
สิ่งที่เราต้องทำที่นี่คือ เราสามารถสร้างจำนวนดาว int ได้
แต่สิ่งที่เราต้องทำคือก่อนอื่นเราต้องส่ง malloc เพราะ malloc
กลับมาพร้อมกับตัวชี้เป็นโมฆะ แต่เราสามารถจัดสรรหน่วยความจำแบบไดนามิกได้
และในที่นี้ เราต้องพูดจริงๆ เพียงเพราะว่าเรากำลังสร้างจำนวนเต็มหนึ่งจำนวน
เราบอกขนาดของ int ได้ และนั่นจะจัดสรรหน่วยความจำให้เรา
แล้ว, สิ่งที่เราต้องทำคือส่งผ่านเข้าไปในสแควร์นัม
แล้วเมื่อเราสร้างสิ่งนี้
มันจะทำสิ่งเดียวกัน แต่ตอนนี้ไม่มีค่าสำหรับ num เลยไม่รู้ว่าจะคำนวณอะไร ดังนั้นคุณต้องกำหนดค่าของ num เราจะบอกว่าที่นี่สี่
คุณไม่อ้างอิงมัน
และตอนนี้
เมื่อคุณสร้างและรัน คุณควรได้ 16
ตอนนี้สิ่งเดียวที่นี่คือเราต้องการพิมพ์ค่าออกมา เราจึงต้องการบอกว่า num
แล้วเมื่อเราเรียกใช้ เราควรเห็น 16
และมันก็เป็นพฤติกรรมแบบเดียวกันจริงๆ
และเราเห็นว่า 16
ความแตกต่างเพียงอย่างเดียวที่นี่คือ เรากำลังจัดสรรหน่วยความจำสำหรับสิ่งที่ชี้ไป
แทนที่จะชี้ไปยังตำแหน่งหน่วยความจำที่มีอยู่ด้วยเครื่องหมายและ
อีกครั้ง สิ่งสำคัญที่ควรทราบในที่นี้ ตัวเลขนี้กำลังเปลี่ยนแปลงนอกฟังก์ชัน
นี้จะถูกส่งผ่านโดยอ้างอิงเข้าใจ
ที่เราใช้ตัวดำเนินการ de-reference
โอเปอเรเตอร์ทางอ้อมเพื่อรับค่าของสิ่งที่ชี้ไป
เข้าใจว่าถ้าฟังก์ชันใช้พอยน์เตอร์และเรามีพอยน์เตอร์
เราก็สามารถส่งชื่อได้
หากไม่ใช่ตัวชี้และเป็นค่าจริง
เราต้องยกเลิกการอ้างอิง
และนี่ก็เหมือนกับ scanf
ตรงนี้เราต้องบอกว่าเครื่องหมายแอมเพอร์แซนด์
และเมื่อเราพิมพ์ออกมา เราก็ไม่ต้องอ้างอิงอะไรทั้งนั้น
เพราะมันไม่ใช่ตัวชี้ และนั่นก็จะเป็นสิ่งเดียวกันที่นี่
แล้วก็เข้าใจ const 2 Const ก่อนที่ int star จะพูดว่าค่าที่ชี้ไปนั้นไม่สามารถเปลี่ยนแปลงได้
const หลังจากการเริ่มต้น int บอกว่าที่อยู่ของตัวชี้ไม่สามารถเปลี่ยนค่าของตัวชี้ได้
ฉันหวังว่านี่จะเป็นประโยชน์
อีกครั้ง เล่นกับสิ่งนี้ เปลี่ยนไวยากรณ์ เลอะเทอะเหมือนที่ฉันทำ
มันจะช่วยให้คุณเรียนรู้ได้มาก ขอขอบคุณ.