สวัสดีและยินดีต้อนรับกลับ
ในการบรรยายนี้ ฉันต้องการพูดคุยเกี่ยวกับการใช้พอยน์เตอร์และโครงสร้าง
ว่ามันเกี่ยวข้องกันอย่างไร
เราสามารถมีองค์ประกอบภายในโครงสร้างเป็นตัวชี้
จากนั้นเราก็สามารถทำให้โครงสร้างของเราเป็นตัวชี้ได้เช่นกัน
สองแนวคิดที่มีประโยชน์มาก
โครงสร้างจึงมีความสำคัญที่นี่ c ช่วยให้พอยน์เตอร์สองโครงสร้าง
ดังนั้นเมื่อเราสร้างตัวแปรประเภทโครงสร้าง เราสามารถสร้างเป็นพอยน์เตอร์ได้
ตัวชี้ไปยังโครงสร้างนั้นง่ายต่อการจัดการมากกว่าตัวโครงสร้างเอง
อีกครั้ง มันเป็นเรื่องของสัญกรณ์ ทำให้สิ่งต่าง
ๆ ง่ายขึ้นมาก และมีประสิทธิภาพมากขึ้นด้วย
ในการใช้งานภาษา c ที่เก่ากว่านั้น โครงสร้างไม่สามารถส่งผ่านเป็นอาร์กิวเมนต์ไปยังฟังก์ชันได้
แต่เรารู้ว่าพอยน์เตอร์ทำได้
นี่เป็นอีกเหตุผลหนึ่งว่าทำไมคุณถึงต้องการให้โครงสร้างเป็นตัวชี้เมื่อคุณประกาศ
เพราะจากนั้นคุณสามารถส่งผ่านมันไปในเวอร์ชันเก่าของ c คุณสามารถส่งผ่านมันเป็นอาร์กิวเมนต์ไปยังฟังก์ชันได้
แม้ว่าคุณสามารถส่งผ่านโครงสร้างเป็นอาร์กิวเมนต์ได้ การส่งตัวชี้จะมีประสิทธิภาพมากกว่า
เรารู้ว่านั่นมีประสิทธิภาพมากกว่า เราเคยพูดถึงเรื่องนี้ในอดีตว่าการผ่านสิ่งสำคัญจะมีประสิทธิภาพมากขึ้นได้อย่างไร
ในกรณีนี้ จะมีประสิทธิภาพมากกว่าเพราะถ้าคุณส่งผ่านโครงสร้างทั้งหมด
ถ้าโครงสร้างมีขนาดใหญ่และมีองค์ประกอบจำนวนมาก คุณกำลังคัดลอกองค์ประกอบทั้งหมดในโครงสร้างไปยังพารามิเตอร์นั้น
หากคุณกำลังส่งตัวชี้เพียงคัดลอกที่อยู่
ดังนั้นจึงสำคัญยิ่งกว่าเมื่อพอยน์เตอร์เป็นอาร์กิวเมนต์ที่มีโครงสร้างเนื่องจากโครงสร้างอาจมีขนาดใหญ่ได้
การแสดงข้อมูลจำนวนมากจึงใช้โครงสร้างที่มีตัวชี้ไปยังโครงสร้างอื่นๆ
คุณจะเห็นสิ่งนี้มากมายในโครงสร้างโปรแกรม
c ทั้งหมดของคุณซึ่งเป็นตัวชี้และด้วยเหตุผลที่เรากล่าวถึง
ความจริงที่ว่าคุณสามารถส่งผ่านพวกมันเป็นพารามิเตอร์ในเวอร์ชันเก่าเพื่อดูได้และยังมีประสิทธิภาพมากกว่าเพราะคุณทำทุกอย่างโดยผ่านค่าซึ่งกำลังคัดลอกมีประสิทธิภาพมากกว่าการคัดลอกที่อยู่มากกว่าการคัดลอกองค์ประกอบทั้งหมดของโครงสร้างขนาดใหญ่นี้
ดังนั้นการประกาศโครงสร้างเป็นตัวชี้ที่ค่อนข้างตรงไปตรงมา
เมื่อคุณกำหนดตัวแปรให้เป็นตัวชี้เพื่อโจมตี คุณเพียงแค่ใช้เครื่องหมายดอกจันหลังประเภทข้อมูล
และเราบอกว่าโครงสร้างเป็นแบบใหม่จริงๆ
ในกรณีนี้ โครงสร้างวันที่สำคัญของเรา
เราแค่พูดว่า struct date แล้วใช้ตัวชี้วันที่ที่มีดอกจัน
และคุณอาจต้องการเริ่มต้นให้เป็นโมฆะ
เนื่องจากจำไว้ว่า เมื่อคุณพูด struct date pointer date struct
date date pointer ที่ไม่ได้จัดสรรหน่วยความจำใด ๆ จะสร้างหน่วยความจำเพื่อเก็บตัวชี้ที่แท้จริง
มันไม่ได้สร้างหน่วยความจำสำหรับข้อมูลภายในของมัน
ดังนั้นคุณสามารถกำหนดให้กับจุดวันที่นี้หรือที่อยู่ของวันที่ที่มีโครงสร้างอื่น
หรือคุณสามารถจัดสรรหน่วยความจำให้อยู่ที่อื่นหรือคุณสามารถเริ่มต้นมันด้วยข้อมูลบางอย่างในลักษณะนั้นได้เช่นกัน
ดังนั้นตัวชี้วันที่แบบแปรผันสามารถกำหนดได้เหมือนกับตัวชี้อื่น
ๆ คุณสามารถกำหนดให้ชี้ไปที่วันที่ของวันนี้ด้วยคำสั่งการมอบหมาย
ดังนั้นถ้าเรามีการประกาศวันที่ของวันนี้แล้ว
เราจะใช้เครื่องหมายและเพื่อให้ได้ที่อยู่ของมัน
ดังนั้นเราจึงสร้างโครงสร้างวันที่ปกติและเป็นวันที่ของวันนี้
จึงจะสร้างความทรงจำให้กับธาตุทั้งสามได้
จากนั้นเราสร้างพอยน์เตอร์และกำหนดที่อยู่ของวันที่อื่น
ค่อนข้างตรงไปตรงมา เราได้ทำอย่างนั้นกับประเภทข้อมูลปกติแล้ว
เมื่อคุณทำกับโครงสร้างก็ไม่ต่างกัน
จากนั้น คุณสามารถเข้าถึงสมาชิกของโครงสร้างข้อมูลที่ชี้ไปตามตัวชี้วันที่ทางอ้อมได้
เราก็เลยต้องทำอย่างนี้.
หากคุณต้องการเข้าถึงองค์ประกอบของโครงสร้างตัวชี้วัน
คุณจะต้องยกเลิกการอ้างอิงก่อน
ดังนั้นมันน่าจะเป็นประโยชน์ถ้าใส่ในวงเล็บเพื่อให้ตรงไปตรงมามาก
คุณต้องยกเลิกการอ้างอิงตัวชี้วันที่เพื่อรับค่าของวันที่ปัจจุบันชี้ไป
ค่าของที่อยู่ของวันที่วันนี้ซึ่งมันชี้ไปเพื่อตั้งค่าเฉพาะ
ดังนั้นคุณจะยกเลิกการอ้างอิงแล้วทำ
dot day เท่ากับ 21 และนั่นจะกำหนด 21 ให้กับตัวชี้วันของคุณ
ข้างต้นเป็นเพียงการบอกว่าวันนี้จะชี้ไปที่วันที่ใด
เราต้องการเข้าถึงค่านั้นและตั้งค่าวันเป็น 21
ในกรณีนี้ จำเป็นต้องใช้วงเล็บเนื่องจากจุดมีความสำคัญมากกว่าเครื่องหมายดอกจัน
หากคุณไม่ใส่วงเล็บลงไป วงเล็บจะพังเพราะจะพยายามทำจุดก่อนที่จะนำตัวชี้ไปยังตัวชี้เพื่อชี้ไปที่ข้อมูล
ดังนั้นมันจะพยายามเข้าถึงข้อมูลด้วยตัวชี้ว่างเป็นหลัก
ดังนั้นโดยการยกเลิกการอ้างอิง คุณจะได้รับค่า
ตอนนี้เมื่อเราใช้ตัวชี้โครงสร้าง
หากเราต้องการทดสอบค่าของเดือนที่จัดเก็บไว้ในโครงสร้างวันที่ที่ชี้ตามตัวชี้วันที่
เราอาจทำสิ่งนี้ได้
เรายกเลิกการอ้างอิงตัวชี้ ใส่ในวงเล็บ ดังนั้นมันจึงมีความสำคัญเหนือจุด
แล้วเราบอกว่า dot month เท่ากับ 12
มันเป็นไวยากรณ์ที่ถูกต้องอย่างสมบูรณ์
แต่มันค่อนข้างยุ่งยากนิดหน่อย
ดังนั้น c มีไวยากรณ์ของตัวเอง ดังนั้นคุณจึงไม่ต้องอ้างอิงทุกอย่างและใส่ไว้ในวงเล็บสำหรับโครงสร้าง
เมื่อคุณต้องการเข้าถึงสิ่งที่โครงสร้างชี้ไป คุณไม่จำเป็นต้องยกเลิกการอ้างอิงด้วยวิธีนี้
มีโอเปอเรเตอร์พิเศษอยู่ใน c สำหรับโครงสร้างของพอยน์เตอร์ และมันเป็นเส้นประที่มากกว่า
เป็นเส้นประตามด้วยเครื่องหมายมากกว่า
และสิ่งนี้ช่วยให้คุณไม่ต้องยกเลิกการอ้างอิงตัวชี้
แทนที่จะทำ star x ในวงเล็บแล้วจุด y คุณก็แค่บอกว่า
x ขีดกลางมากกว่า y ก็ได้
เนื่องจาก x เป็นตัวชี้ คุณจึงไม่ต้องอ้างอิงและต้องการเข้าถึงองค์ประกอบภายในโครงสร้างนั้นไม่ว่าคุณกำลังชี้ไปที่อะไร
คุณจะเห็นรูปแบบนี้ทั่วๆ ไป คุณจะไม่เห็นวงเล็บและการอ้างอิง
d ถูกต้องอย่างสมบูรณ์ แต่คุณกำลังพิมพ์อักขระเพิ่มเติม
มันมีประสิทธิภาพมากกว่าที่จะพูดว่า x ขีดกลางมากกว่า y
ดังนั้นคำสั่ง if ก่อนหน้านี้บนนี้ แทนที่จะยกเลิกการอ้างอิงภายในวงเล็บ สิ่งที่คุณต้องทำคือบอกว่าถ้าตัวชี้วันที่มากกว่าเดือน
และมันก็ค่อนข้างเข้าใจได้ง่ายเพราะเส้นประที่มากกว่าการบอกว่ามันชี้ไปที่บางสิ่งบางอย่าง
และเส้นประวันที่มากกว่าเดือน
ดังนั้นตัวชี้วันที่จึงเป็นตัวชี้ และนั่นคือสาเหตุที่คุณใช้เส้นประที่มากกว่า
ทีนี้ ถ้านั่นเป็นโครงสร้างที่ซ้อนกัน คุณจะทำเส้นประมากกว่าโครงสร้าง
จากนั้นคุณจะต้องทำจุดหลังจากนั้นเพื่อเข้าถึงองค์ประกอบของโครงสร้างที่ซ้อนกัน
แต่เนื่องจากตัวชี้วันเป็นตัวชี้ คุณต้องใช้เส้นประเท่ากับหรือเส้นประมากกว่า
นี่คือตัวอย่าง เรากำลังสร้าง struct date ของเรา เรามีสามองค์ประกอบ จากนั้นเรากำลังสร้างตัวชี้
date pointer ของเรา และเรากำลังสร้างเพียงตัวแปรปกติในวันนี้
เรากำหนดที่อยู่ของวันนี้ให้กับตัวชี้ของเรา
จากนั้นเพื่อกำหนดองค์ประกอบที่แท้จริงของโครงสร้าง เราแค่ใช้เส้นประนั้นมากกว่าจากนั้นเราก็สามารถพิมพ์ออกมาได้
ลองดูสิ่งนี้ในบล็อคโค้ดเพื่อดูว่ามันทำงานอย่างไร
ผมจะยกตัวอย่างนี่ตรงนี้
และโดยปกติเมื่อคุณกำหนดโครงสร้าง คุณจะกำหนดโครงสร้างภายนอกฟังก์ชันเพราะจากนั้นคุณสามารถใช้โครงสร้างเหล่านี้ในฟังก์ชันใดก็ได้
มันเหมือนเป็นสากล แต่จำไว้ว่าเมื่อคุณกำหนดโครงสร้าง
คุณไม่ได้สร้างหน่วยความจำขึ้นมาจริงๆ
ดังนั้น คุณยังคงสร้างตัวแปรเป็นตัวแปรโลคัลหรือพอยน์เตอร์ แต่คำจำกัดความที่แท้จริงนั้นอยู่นอกฟังก์ชัน
ดังนั้นหากคุณต้องการใช้งาน คุณสามารถใช้มันในฟังก์ชันใดก็ได้
ที่ด้านบนนี้ เราได้สร้างโครงสร้างใหม่ของประเภทวันที่หรือชื่อจนถึงปัจจุบัน
และประกอบด้วยจำนวนเต็มสามจำนวน เราลงท้ายด้วยเครื่องหมายอัฒภาค
จากนั้นเราสร้างตัวแปรสองตัวภายในตัวหลัก
ตัวแปรหนึ่งที่เป็นเพียงแค่วันที่ของโครงสร้างตัวแปรปกติในวันนี้
และอีกอันที่เป็นตัวชี้ เรารู้ว่ามันเป็นพอยน์เตอร์เพราะมันมีดอกจันอยู่ข้างหน้า
เรารู้ว่าพอยน์เตอร์เมื่อคุณสร้างพอยน์เตอร์ มันจะสร้างเฉพาะหน่วยความจำที่จัดสรรเพื่อจัดเก็บที่อยู่นั้นสำหรับค่านั้นของตัวชี้นั้น
ดังนั้นเราจึงต้องกำหนดที่อยู่ที่เราทำกับเครื่องหมายและวันนี้
เพราะมันสร้างรายงานหน่วยความจำจริงๆ
ดังนั้นตอนนี้ตัวชี้วันที่จะชี้ไปที่สิ่งที่อยู่ของวันนี้ด้วยที่อยู่ของวันนี้
จากนั้นเราสามารถเริ่มกำหนดข้อมูลได้โดยใช้เส้นประนี้ซึ่งมีประโยชน์มากกว่า และเพียงแค่กำหนดข้อมูลเหมือนกับคนอื่นๆ
เพียงแค่ใช้ตัวดำเนินการมอบหมาย
จากนั้นเมื่อเราพิมพ์ออกมา คุณจะสังเกตเห็นว่าเราไม่จำเป็นต้องยกเลิกการอ้างอิงเพื่อพิมพ์ออกมา
เพื่อพิมพ์ออกมา เราสามารถพูดได้จริง
ๆ ว่าชนิดข้อมูลสำหรับตัวระบุรูปแบบที่นี่ เปอร์เซ็นต์ที่สูงกว่า เปอร์เซ็นต์
d เท่ากันสำหรับจำนวนเต็ม แล้วเราก็แค่ใช้ dash grader เพราะนั่นเป็นการยกเลิกการจำการอ้างอิง
ตอนนี้เราสามารถเปลี่ยนแปลงสิ่งนี้และสิ่งนี้จะถูกต้อง
เราต้องใส่วงเล็บแล้วบอกว่าเดือนดอท
ทั้งสองวิธีก็ใช้ได้ แต่ทำความคุ้นเคยกับเส้นประแล้วให้มากขึ้นเพราะมันเป็นไวยากรณ์ที่ดีกว่า
และตอนนี้เมื่อเราสร้างสิ่งนี้
คุณจะเห็นว่ามันพิมพ์ค่าตัวชี้วันที่และตั้งค่าทั้งหมดเป็น
9 25 และ 2015
มันบอกว่าวันนี้คือ 9 25 15 มันถูกจัดรูปแบบเพื่อพิมพ์ออกมาแบบนั้น
สิ่งที่ค่อนข้างตรงไปตรงมา
เพียงจำไว้ว่าเส้นประนั้นมากกว่า นั่นคือไวยากรณ์ใหม่สำหรับตัวชี้ไปยังโครงสร้าง
แต่อย่างอื่นที่นี่เป็นเรื่องปกติ
เรารู้ว่าพอยน์เตอร์ต้องมีที่ที่อยู่ร้านค้า ดังนั้นเรารู้ว่าเราต้องจัดสรรหน่วยความจำไดนามิกหรือเราต้องกำหนดโครงสร้างที่มีอยู่
กลับมาพูดถึงโครงสร้างและพอยน์เตอร์กันดีกว่า
ทีนี้มาพูดถึงโครงสร้างที่มีพอยน์เตอร์กัน
เรารู้วิธีสร้างตัวชี้สำหรับโครงสร้าง
เราสามารถจัดสรรหน่วยความจำสำหรับตัวชี้นั้นได้ หากเราไม่ต้องการกำหนดที่อยู่ที่มีอยู่ของตัวชี้ที่มีอยู่
แต่คุณสามารถมีองค์ประกอบภายในโครงสร้างที่เป็นตัวชี้ได้
ดังนั้นพอยน์เตอร์อาจเป็นสมาชิกของโครงสร้างก็ได้
เราไม่จำเป็นต้องใช้อาร์เรย์อักขระนั้น
เราสามารถพูดได้ว่า struct, เราสามารถตั้งชื่อมันในพอยน์เตอร์
แล้วเราก็สามารถใช้ที่นี่ในตัวอย่างนี้ เรามีจำนวนเต็มสองตัว, พอยน์เตอร์จำนวนเต็มสองตัว p1
และ p2, ไวยากรณ์ที่ถูกต้องสมบูรณ์ในการทำเช่นนั้น
ดังนั้นโครงสร้างที่เรียกว่าพอยน์เตอร์จึงถูกกำหนดให้มีพอยน์เตอร์จำนวนเต็มสองตัว
อันแรกเรียกว่า p1 อันที่สองเรียกว่า p2
คุณสามารถกำหนดตัวแปรของประเภท struct ในพอยน์เตอร์ได้เหมือนกับปกติ,
struct, ตัวชี้ int, พอยน์เตอร์
ตอนนี้พอยน์เตอร์ตัวแปรสามารถใช้ได้เหมือนกับโครงสร้างอื่นๆ
พอยน์เตอร์ไม่ใช่ตัวชี้
มันเป็นตัวชี้ int มันมีองค์ประกอบสองอย่างที่อยู่ภายในการโจมตีซึ่งเป็นตัวชี้
แต่ตัวชี้เองไม่ใช่ตัวชี้ที่แท้จริง
ดังนั้นจงใส่ใจกับสิ่งนั้น เป็นตัวแปรโครงสร้างที่มีตัวชี้สองตัวเป็นสมาชิก
ซึ่งต่างกัน
ดังนั้นถ้าเราต้องการเข้าถึงองค์ประกอบภายในตัวแปรพอยน์เตอร์ซึ่งอยู่ในพอยน์เตอร์
เราอย่าใช้ขีดกลางมากกว่าเพราะพอยน์เตอร์ไม่ใช่พอยน์เตอร์
แต่เป็นโครงสร้าง
เราจะใช้จุดเพื่อเข้าถึง
p1 และเข้าถึง p2
ในตัวอย่างนี้ เราสร้างโครงสร้างของเรา
เราสร้างตัวแปร ไม่ใช่ตัวชี้ที่เรียกว่าพอยน์เตอร์
แล้วเราก็สร้างจำนวนเต็มสองจำนวน คือ
i1 เท่ากับ 100 และ i2 ซึ่งไม่ได้กำหนดค่าเริ่มต้น
ตอนนี้ p1 และ p2 เป็นตัวชี้
ดังนั้นจะต้องมีที่อยู่หน่วยความจำที่ถูกต้องซึ่งที่อยู่ได้รับการจัดสรรหน่วยความจำ
และนั่นคือสิ่งที่ใน i1 และ i2 กำลังทำอยู่
เมื่อคุณประกาศตัวแปรจำนวนเต็ม หน่วยความจำจะถูกจัดสรรสำหรับจำนวนเต็มเหล่านั้น
ดังนั้น โดยการกำหนดที่อยู่ i1 และ i2 ให้กับ p1 และ p2 นั่นก็ถือว่าใช้ได้อย่างสมบูรณ์เพราะ
i1 และ i2 มีหน่วยความจำที่จัดสรรไว้เพราะเป็นจำนวนเต็ม
ทีนี้ ถ้าพอยน์เตอร์จำนวนเต็มไม่ใช่พอยน์เตอร์จำนวนเต็ม แต่เป็นพอยน์เตอร์ของอักขระ
คุณจะต้องจัดสรรหน่วยความจำไดนามิก
ตอนนี้เราแค่ใช้จำนวนเต็ม เราจึงกำหนดที่อยู่ของจำนวนเต็มทั้งสองให้กับ p1 และ p2
ตอนนี้เราสามารถพูดพอยน์เตอร์ดาวได้แล้ว p2 เท่ากับ 97,
ลบ 97
เหตุใดเราจึงต้องยกเลิกการอ้างอิงที่นั่นเพราะตัวชี้
p2 คือสิ่งที่เรากำลังอ้างอิง
พอยน์เตอร์ pt p2 เป็นตัวชี้
เราไม่ได้เข้าถึงองค์ประกอบของโครงสร้าง
เรากำลังยกเลิกการอ้างอิงตัวชี้ทั้งหมด หน้า2
และเราจะกำหนดค่าของสิ่งนั้น ไม่ว่ามันจะชี้ไปที่ลบ 97
ดังนั้นสังเกตความแตกต่างที่นั่น
เราไม่ได้สร้างตัวชี้โครงสร้าง
เรากำลังสร้างตัวชี้ตัวแปรปกติ แต่มีองค์ประกอบสองอย่างที่เป็นตัวชี้
ดังนั้นถ้าเราต้องการกำหนดให้กับสององค์ประกอบภายในโครงสร้าง เราต้องยกเลิกการอ้างอิงโดยใช้ตัวดำเนินการทางอ้อม
และนั่นคือสิ่งที่เราทำที่นั่น
แล้วในข้อความสั่งพิมพ์ทั้งสองของเรา
อีกครั้ง เราต้องการพิมพ์ค่าของสิ่งที่ p1 ชี้ไป ดังนั้นเราจึงยกเลิกการอ้างอิงมันเหมือนกับ
p2 จากนั้นเราต้องการพิมพ์ค่าที่ตัวชี้ชี้ไปอีกครั้งด้วย
ในอันแรกนั้น เรากำลังบอกว่า i1 เท่ากับเปอร์เซ็นต์
I ตัวชี้ลูกน้ำ p1 เท่ากับเปอร์เซ็นต์
I
ดังนั้นอันแรกในเครื่องหมายอัญประกาศคู่ก็แค่พิมพ์ข้อความจริงนั้นออกมา
ไม่ได้ตัดการอ้างอิงใดๆ หลังจากเครื่องหมายจุลภาคเป็นที่ที่เรากำลังยกเลิกการอ้างอิง
อันดับแรก เรากำลังพิมพ์ i1 ซึ่งเท่ากับ 100
จากนั้นจึงพิมพ์ตัวชี้ p1 ซึ่งจะเป็น 100
I2 จะเป็นลบ 97 หลังจากที่เรากำหนดให้
p2
แล้วอาร์เรย์อักขระหรือพอยน์เตอร์อักขระล่ะ ในการบรรยายครั้งก่อน เราได้พูดถึงวิธีสร้างอาร์เรย์อักขระเป็นองค์ประกอบภายในตัวชี้
แต่สิ่งที่เกี่ยวกับพอยน์เตอร์อักขระ
เราควรทำอะไรเช่น first และ last have character
arrays หรือเราควรทำอะไรบางอย่างเช่น first และ last โดยมีตัวชี้อักขระเป็นองค์ประกอบ
ทางเลือกไหนดีกว่ากัน.
เราจะเห็น เป็นเรื่องสัญกรณ์จริง ๆ อีกครั้ง แต่มีข้อดีในการใช้พอยน์เตอร์
ดังนั้นเมื่อเราสร้างพอยน์เตอร์ให้กับตัวละครภายในองค์ประกอบของเรา
มันมักจะดีขึ้นเล็กน้อย
แต่คุณต้องเข้าใจว่าเกิดอะไรขึ้นเมื่อคุณสร้างองค์ประกอบอาร์เรย์ ถ่านอาร์เรย์
เป็นองค์ประกอบหรือตัวชี้เป็นองค์ประกอบ ทั้งสองสิ่งถูกต้อง
แต่มีความแตกต่างใหญ่
ดังนั้นถ้าเราพูดชื่อ struct
veep หรือ vp และเราพูดว่า Talia และ Summers จากนั้นเราพูดชื่อ
struct pointer ดังนั้น โปรดจำไว้ว่า ชื่อโครงสร้างประกอบด้วยอาร์เรย์อักขระ
ชื่อตัวชี้โครงสร้างประกอบด้วยตัวชี้
และเรากำลังเริ่มต้นพอยน์เตอร์เท่ากับ Brad และ Fallingjaw
จากนั้นเราพิมพ์ออกมา เราจะพิมพ์องค์ประกอบแรกออกมา
ซึ่งก็คืออักขระ a และ vp จากนั้นองค์ประกอบแรกของ
treas ซึ่งเป็นตัวชี้ไปที่ก่อน
ดังนั้นชื่อโครงสร้างตัวแปร veep
สิ่งที่เกิดขึ้นที่นี่คือสตริงที่เก็บไว้ภายในโครงสร้าง
โครงสร้างได้จัดสรรไว้ทั้งหมด 40 ไบต์เพื่อเก็บชื่อทั้งสองไว้
เป็นอาร์เรย์อักขระ
นั่นคือสิ่งที่เกิดขึ้นเมื่อเราสร้างอาร์เรย์อักขระภายในตัวชี้
เรากำลังจัดสรร 40 ไบต์เพื่อเก็บสองชื่อนั้นไว้
คือ 20 และ 20
สำหรับตัวแปรชื่อพอยน์เตอร์ถือว่าเรามีสองพอยน์เตอร์ตัวแรกและตัวสุดท้ายหรือไม่ สิ่งเหล่านี้คือสตริงที่เก็บไว้ที่ใดก็ตามที่คอมไพเลอร์เก็บค่าคงที่สตริง
โครงสร้างเก็บที่อยู่ทั้งสองไว้เพราะเป็นตัวชี้
พอยน์เตอร์ประกอบด้วย อะไร ค่าที่เป็นที่อยู่
สิ่งที่ต้องทำคือจัดสรรพอยน์เตอร์สองตัวภายในโครงสร้างนั้น
นั่นคือ 16 ไบต์สำหรับระบบส่วนใหญ่ ตัวชี้มักจะ 8 ไบต์หรือ 4 ไบต์
โครงสร้างชื่อ struct p ไม่จัดสรรพื้นที่สำหรับเก็บสตริง เนื่องจากเป็นการจัดสรรพื้นที่สำหรับพอยน์เตอร์เท่านั้น
พอยน์เตอร์มีค่าที่เป็นที่อยู่
ที่อยู่ที่ชี้ไปไม่มีการจัดสรรหน่วยความจำสำหรับสิ่งนั้น
ดังนั้นเมื่อคุณสร้างพอยน์เตอร์สองตัวนั้น ไม่มีหน่วยความจำที่จัดสรรไว้สำหรับพอยน์เตอร์สองตัวนั้น
มันจัดสรรพื้นที่ไม่มี
ดังนั้นจึงสามารถใช้ได้เฉพาะกับสตริงที่มีการจัดสรรพื้นที่สำหรับไว้ที่อื่นเท่านั้น
เมื่อใดก็ตามที่คุณมีตัวชี้อยู่ภายในโครงสร้าง
คุณต้องใช้ malloc หรือ calloc
มิฉะนั้น พวกเขาสามารถเก็บไว้ได้ทุกที่ที่จัดเก็บค่าคงที่สตริง
และนั่นคือความแตกต่างที่ยิ่งใหญ่ ดังนั้นพอยน์เตอร์และโครงสร้างชื่อ
p ควรใช้เพื่อจัดการสตริงที่สร้างและจัดสรรไว้ที่อื่นในโปรแกรมเท่านั้น
คุณไม่ต้องการกำหนดข้อมูลให้กับสิ่งนั้น
เว้นแต่คุณจะจัดสรรแบบไดนามิกหรือได้รับการจัดสรรที่อื่น อาจโดยโครงสร้างที่มีอยู่หรือบางอย่าง
แต่โดยทั่วไป คุณจะต้องการชี้แนะเหล่านั้น
อีกครั้งที่แตกต่างกันมาก
คุณกำลังจัดสรร 40 ไบต์สำหรับอาร์เรย์อักขระสองตัวนี้ภายในโครงสร้างชื่อ
สำหรับโครงสร้างชื่อ p คุณมีสองพอยน์เตอร์
ไม่มีการจัดสรรหน่วยความจำสำหรับสิ่งนั้นเมื่อคุณสร้างตัวแปรประเภทนั้น
เป็นเพียงการสร้างหน่วยความจำสำหรับพอยน์เตอร์สองตัว ซึ่งแต่ละอันมีขนาดแปดไบต์
ในการจัดสรรหน่วยความจำสำหรับสิ่งแรกและตัวสุดท้ายที่ชี้ไป คุณต้องทำ malloc
ดังนั้นอินสแตนซ์หนึ่งที่เหมาะสมที่จะใช้ตัวชี้และโครงสร้างคือการจัดการสตริงคือถ้าคุณกำลังจัดสรรหน่วยความจำนั้นแบบไดนามิก
โดยปกติแล้วเมื่อคุณใช้ข้อมูลดังกล่าว
เนื่องจากประเภทข้อมูลที่ได้รับอนุญาตอื่นๆ จะจัดสรรหน่วยความจำให้คุณโดยอัตโนมัติ
คุณจึงต้องการใช้ตัวชี้เพื่อจัดเก็บที่อยู่
มีข้อได้เปรียบที่คุณสามารถขอให้ malloc จัดสรรเฉพาะจำนวนพื้นที่ที่จำเป็นสำหรับสตริง
เราได้พูดถึงข้อดีของการจัดสรรหน่วยความจำแบบไดนามิก
เมื่อคุณสร้างสิ่งต่าง ๆ แบบสแตติก ณ เวลาคอมไพล์ คุณจะสร้างเฉพาะจำนวนไบต์ที่ระบุเท่านั้น
จะเกิดอะไรขึ้นถ้าคุณต้องการไบต์เพิ่ม แย่แล้ว โปรแกรมของคุณไม่ทำงาน
คุณต้องย้อนกลับไปและคอมไพล์ใหม่ ด้วยสตริงที่จัดสรรแบบไดนามิก คุณสามารถปรับใหม่ได้
คุณสามารถสร้างหน่วยความจำได้มากเท่าที่ต้องการ ซึ่งทำให้โปรแกรมมีประสิทธิภาพมากขึ้น
ดังนั้นคุณจะใช้ malloc กับพอยน์เตอร์ที่สร้างภายในโครงสร้าง
ดังนั้นในกรณีนี้ คุณมีโครงสร้างที่ตั้งชื่อการนับชื่อ
คุณมีสองพอยน์เตอร์ ตัวชี้อักขระ fname และนามสกุล
แล้วคุณมี int, ตัวอักษร
สองสตริงภายในที่นี่จะไม่ถูกเก็บไว้ในโครงสร้าง
เราสร้างหน่วยความจำสำหรับพอยน์เตอร์ซึ่งมีที่อยู่เท่านั้น
เราต้องการสร้างหน่วยความจำสำหรับ fname และ lname สำหรับสิ่งที่พอยน์เตอร์ชี้ไป
ดังนั้นเราจึงต้องการเก็บไว้ในกลุ่มที่จัดการโดยตำแหน่งหน่วยความจำแบบไดนามิก ซึ่งใช้ malloc
ที่อยู่ของสตริงทั้งสองคือสิ่งที่เก็บไว้ ไม่ใช่สิ่งที่กำลังชี้ไป
ดังนั้นที่อยู่คือสิ่งที่ฟังก์ชันการจัดการสตริงมักจะใช้งานได้ ซึ่งเป็นสิ่งที่ดี
และนั่นเป็นสาเหตุที่คุณต้องการใช้พอยน์เตอร์ในนั้น เพราะคุณไม่จำเป็นต้องทำอย่างนั้น
คุณสามารถส่งต่อได้ง่ายขึ้นมาก
นี่คือตัวอย่าง เรามีฟังก์ชั่นที่เรียกว่ารับข้อมูล
มันต้องใช้ตัวชี้
และเราสามารถส่งผ่านตัวชี้นั้นไปรอบๆ ได้ง่ายมาก
ตอนนี้เรากำลังจะสร้างอาร์เรย์ตัวชี้อีกตัวหนึ่งหรือสำหรับอาร์เรย์ตัวชี้ที่ส่งต่อไปยังอาร์เรย์นั้น
เราจะจัดสรรหน่วยความจำสำหรับอาร์เรย์นั้น
คุณจะเห็นว่าเราสร้างอักขระที่เรียกว่า temp จากนั้นเราเก็บข้อมูลบางส่วนไว้ใน
temp นั้น
เราขอให้ผู้ใช้ได้รับบางสิ่งบางอย่าง เราไม่คุ้นเคยกับ sgets แต่ก็เหมือนกับการได้รับการบันทึก scanf เล็กน้อย
จากนั้นเราจัดสรรหน่วยความจำสำหรับ fname ภายในพอยน์เตอร์นั้น และเราทำอย่างนั้นเหมือนกับที่เราจัดสรรหน่วยความจำสำหรับอักขระใดๆ
เราเรียก
malloc เราส่งผ่านจำนวนไบต์
ในกรณีนี้ ความยาว str เป็น 10 บวก 1 สำหรับตัวสิ้นสุดค่า null
แล้วอย่าลืมว่า malloc กลายเป็นดาวที่ว่างเปล่า ดังนั้นเราจึงโยนมันให้เป็นดาราของตัวละคร
แต่นี่เป็นสิ่งสำคัญที่นี่ การเรียก malloc นี้จำเป็นสำหรับโครงสร้างใดๆ ที่มีพอยน์เตอร์
ตอนนี้เราส่งผ่านตัวชี้นี้เข้าไป และตัวชี้ไม่เคยได้รับการจัดสรรหน่วยความจำสำหรับมัน
เราเลยจัดสรรหน่วยความจำไว้ที่นี่ เราก็สามารถทำสำเนาของเราได้ง่ายมาก
เราสามารถคัดลอก temp ไปยัง fname ของ pst โครงสร้างของเราที่ส่งผ่านเป็นพารามิเตอร์
จากนั้นเราสามารถให้พวกเขาป้อนนามสกุล เราสามารถ malloc หน่วยความจำเพิ่มเติมสำหรับนามสกุลแล้วเก็บไว้ในตัวแปร
struct นามสกุล
นี่คือสิ่งที่คุณจะต้องทำเมื่อคุณมีตัวชี้ไปยังตัวละครในโครงสร้างของคุณ
คุณต้องทำ Malloc
เพราะอีกครั้ง พอยน์เตอร์เหล่านั้นเก็บเฉพาะที่อยู่เท่านั้น
พวกเขาจัดสรรหน่วยความจำเพียงพอที่จะเก็บที่อยู่ มีหน่วยความจำไม่เพียงพอที่จะเก็บสตริง
ดังนั้นไม่ว่าที่อยู่นั้นจะชี้ไปอย่างไร คุณต้องจัดสรรหน่วยความจำสำหรับสิ่งนั้น
และคุณทำเหมือนกับปกติกับ malloc ความแตกต่างเพียงอย่างเดียวคือที่นี่คุณใช้เส้นประมากกว่าเครื่องหมายเพื่อเข้าถึงองค์ประกอบจริงภายในโครงสร้างนั้น
ซึ่งก็คือ ตัวชี้อักขระ เพื่อให้คุณสามารถกำหนดให้กับตัวชี้นั้นได้ และนั่นคือการยกเลิกการอ้างอิง
ดังนั้นคุณจะต้องการเล่นกับสิ่งนี้ นี่เป็นเรื่องปกติมากสำหรับพอยน์เตอร์อักขระภายในโครงสร้าง
เรากำลังจะมีความท้าทายที่คุณต้องทำสิ่งนี้ แต่ลองใช้โค้ดนี้ เข้าไปในบล็อคโค้ด
เริ่มจัดสรรหน่วยความจำสำหรับสตริงหรือพอยน์เตอร์อักขระภายใน
struct และดูว่าคุณสามารถใช้ str copy เพื่อใส่ข้อมูลลงในนั้นได้อย่างไร
แต่คุณต้องจัดสรรหน่วยความจำก่อนจึงจะกำหนดได้ .
หากคุณกำลังทำค่าคงที่เหมือนในตัวอย่างก่อนหน้านี้ที่รู้ว่าหน่วยความจำนั้นถูกจัดสรรไว้ที่ใด
อีกครั้ง แนวคิดที่สำคัญมากมายที่นำเสนอในการบรรยายครั้งนี้
แนวคิดของโครงสร้างที่เป็นตัวชี้ในไวยากรณ์ใหม่นี้
ซึ่งคุณสามารถใช้เส้นประนั้นมากกว่าเมื่อเทียบกับการใช้ตัวดำเนินการทางอ้อม
ดีมาก
แล้วมีองค์ประกอบเป็นตัวชี้และวิธีที่คุณต้องจัดสรรหน่วยความจำสำหรับพอยน์เตอร์อักขระ
ขอขอบคุณ.