สวัสดีและยินดีต้อนรับกลับ สิ่งสุดท้ายที่ฉันต้องการพูดถึงเกี่ยวกับโครงสร้างคือวิธีที่พวกมันเกี่ยวข้องกับฟังก์ชัน
คุณจะส่งผ่านโครงสร้างเป็นอาร์กิวเมนต์ไปยังพารามิเตอร์และฟังก์ชันได้อย่างไร และวิธีนี้มีประสิทธิภาพมากขึ้นเช่นกัน
โครงสร้างจึงเป็นอาร์กิวเมนต์ของฟังก์ชัน
หลังจากประกาศโครงสร้างชื่อแฟมิลี่
ในตัวอย่างนี้
เราจะสร้างครอบครัวที่มีชื่อ เราจะส่งผ่านโครงสร้างนี้เป็นอาร์กิวเมนต์ไปยังฟังก์ชันได้อย่างไร
ดังนั้นเราจึงมีโครงสร้างที่เรียกว่า Family
เรามีอาร์เรย์ของตัวละครในที่นี้ชื่อ
พ่อและแม่ จากนั้นเราก็มีอายุที่เพียงพอ
นั่นคือคำจำกัดความโครงสร้างของเรา
เรารู้ว่ามันเป็นโครงสร้างเพราะมีคีย์เวิร์ด struct ตามด้วยชื่อแท็กที่เรามีวงเล็บปีกกาและอื่นๆ
ทีนี้เราจะส่งต่อโครงสร้างนั้นไปยังฟังก์ชันที่เรียกว่าพี่น้องได้อย่างไร
คุณจะทำเหมือนกับที่คุณประกาศโครงสร้าง คุณจะพูดว่า
type เป็นชื่อพารามิเตอร์
มันตรงไปตรงมาจริงๆ ในกรณีนี้ เรามีพี่น้องบูลีน
พี่น้องกำลังส่งคืนบูลีน
และมันใช้พารามิเตอร์สองตัว พารามิเตอร์โครงสร้างสองตัว
คุณต้องระบุประเภท struct ซึ่งเป็นประเภท struct family
ตอนนี้ใน c ขั้นสูงกว่านี้ คุณสามารถพิมพ์
typedf บน struct นี้และตั้งชื่ออย่างอื่น และคุณสามารถย่อชื่อที่นี่
แต่เราไม่ได้พูดถึง typeds
นั่นน่าจะดีกว่า
แต่นี่เป็นวิธีที่คุณจะต้องทำจริงๆ คุณจะต้องกำหนดประเภททั้งหมด ซึ่งก็คือ
struct family และตามด้วยชื่อตัวแปร เช่นเดียวกับพารามิเตอร์อื่นๆ
ตรงนี้เรากำลังส่งผ่านพารามิเตอร์สองตัว คือ เมมเบอร์หนึ่งและเมมเบอร์สอง
ทั้งคู่เป็นประเภท struct family
ภายในฟังก์ชันของเรา หากเราต้องการเข้าถึงสมาชิก เราจะเข้าถึงสมาชิกได้ตามปกติ
สมาชิกที่หนึ่งและสมาชิกที่สอง พวกมันไม่ใช่ตัวชี้ ดังนั้นเราจะไม่ใช้ขีดกลางมากกว่านั้น เราทำอย่างนั้นกับตัวชี้เท่านั้นเพราะเราต้องยกเลิกการอ้างอิงเพื่อดูว่าพวกเขากำลังชี้ไปที่อะไร
เพราะมันไม่ใช่ตัวชี้ เราทำได้แค่จุด ดังนั้นเมมเบอร์หนึ่งดอท, เมมเบอร์สองดอทมาเธอร์
สมาชิก one dot mother และ mother two dot mother เป็นอาร์เรย์อักขระ
และอาร์เรย์อักขระเป็นตัวชี้โดยพื้นฐานแล้ว
ดังนั้นเราจึงสามารถส่งต่อไปยัง str เปรียบเทียบได้ Str Compare จะกลับมาเท่ากับถ้ามันเหมือนกัน สิ่งที่เราทำที่นี่คือเรากำลังตรวจสอบสมาชิกหนึ่งคนแม่และสมาชิกสองคนแม่สองคนเหมือนกัน
และถ้าเป็นเช่นนั้น เราจะคืนค่า จริง
เพราะถ้าทั้งคู่มีชื่อเหมือนกันและนั่นเป็นนามสกุลจริง
ๆ พวกเขาก็เป็นพี่น้องกัน
ค่อนข้างตรงไปตรงมา
ง่ายต่อการส่งผ่านอาร์กิวเมนต์ไปยังฟังก์ชัน
ตราบใดที่การประกาศฟังก์ชันมีโครงสร้างประเภทนั้นอยู่ในนั้น
ดังนั้น ฟังก์ชันนี้ อีกครั้ง พารามิเตอร์สองตัว ซึ่งแต่ละตัวเป็นโครงสร้างของตระกูลประเภท
แล้วถ้าเราต้องการให้พอยน์เตอร์ไปยังโครงสร้างเป็นอาร์กิวเมนต์ของฟังก์ชันล่ะ
และที่ฉันได้กล่าวไว้ก่อนหน้านี้ว่า ควรทำอย่างนี้ดีกว่า
เพราะเรากำลังทำผ่านค่าและค
เมื่อคุณผ่านค่า คุณคัดลอก
หากคุณมีโครงสร้างที่มีข้อมูลจำนวนมาก โครงสร้างขนาดใหญ่จำนวนมากเป็นอาร์กิวเมนต์
คุณต้องคัดลอกทุกอย่างในโครงสร้างนั้นไปยังฟังก์ชันจริง
อาจต้องใช้เวลาสักระยะในการคัดลอกโครงสร้างขนาดใหญ่เหล่านั้น
ถ้าคุณมีพอยน์เตอร์ สิ่งที่คุณต้องทำคือคัดลอกที่อยู่ซึ่งเร็วกว่ามาก
ดังนั้นตัวชี้ไปยังโครงสร้างจึงถูกใช้เป็นพารามิเตอร์และฟังก์ชันเพื่อหลีกเลี่ยงการใช้หน่วยความจำและเวลาที่ใช้ในการคัดลอกโครงสร้างทั้งหมด
ตอนนี้ถ้าคุณมีโครงสร้างขนาดเล็ก ไม่ใช่เรื่องใหญ่
แต่ต้องการใช้ตัวชี้และโครงสร้างที่ใหญ่อย่างแน่นอน
ดังนั้นในกรณีนี้ คุณจะทำอย่างไร คุณยังคงระบุชื่อประเภทของโครงสร้าง คุณเพียงแค่ใส่เครื่องหมายดอกจันไว้ข้างหน้า
ง่ายมาก และถ้าคุณไม่ต้องการให้ข้อมูลใดๆ
ภายในโครงสร้างเปลี่ยนแปลง คุณสามารถใช้ค่าคงที่ก่อนประเภทโครงสร้างได้
หากคุณไม่ต้องการเปลี่ยนที่อยู่ คุณจะต้องใส่ค่าคงที่หลังตัวชี้ตระกูล struct
แต่ที่นี่เราทำสิ่งเดียวกัน แต่ตอนนี้เรากำลังจะเข้าถึงมันอย่างแตกต่างออกไป
เพราะตอนนี้มันเป็นพอยน์เตอร์แล้ว เราสามารถใช้เส้นประมากกว่าสัญลักษณ์ใหม่นั้นเพื่อเข้าถึงแทนที่จะใช้จุด
เราไม่จำเป็นต้องใช้จุดตรงนี้ เพราะจำไว้ว่าพอยน์เตอร์คุณต้องยกเลิกการอ้างอิงก่อน
ดังนั้นคุณต้องใส่ไว้ในวงเล็บ มันเป็นไวยากรณ์มากกว่าที่จะยกเลิกการอ้างอิงตัวชี้
จากนั้นคุณจะต้องวางจุดนอกวงเล็บ เพราะมันมีความสำคัญสูงกว่ามาก ใช้เส้นประง่ายกว่ามากกว่า
เส้นประและมากกว่าแม่ เส้นประและมากกว่าแม่
ทั้งคู่เป็นตัวชี้ สามารถส่งผ่านใน str เปรียบเทียบได้
หากเหมือนกัน ให้คืนค่า จริง มิฉะนั้น คืนค่าเท็จ ค่อนข้างตรงไปตรงมา
คุณยังสามารถใช้ตัวแก้ไข const ตามที่ได้กล่าวไว้หากคุณไม่ต้องการอนุญาตการแก้ไขใดๆ
ของสมาชิกของโครงสร้าง
struct ชี้ไปที่อะไร จากนั้นให้ใส่ const หน้าตัวชี้
คุณสามารถใส่ const ก่อนครอบครัวได้เช่นกัน
ในกรณีนี้ ครอบครัวจะมีตัวพิมพ์
ดังนั้นที่นี่จะเป็นตัวสร้าง
family หรือ struct family const pointer
แล้วเข้าถึงด้วยวิธีเดิมอีกครั้ง คุณไม่ได้แก้ไขอะไรเลย ดังนั้นคุณพร้อมที่จะไป
คอมไพเลอร์จะไม่บ่น
คุณยังสามารถใช้ตัวแก้ไขค่าคงที่ได้ หากคุณไม่ต้องการอนุญาตให้แก้ไขที่อยู่เอง
ความพยายามใดๆ ในการเปลี่ยนแปลงโครงสร้างเหล่านี้จะทำให้เกิดข้อความแสดงข้อผิดพลาดในระหว่างการคอมไพล์
ในที่นี้ คุณจะบอกว่าดาราครอบครัว
แล้วใส่ค่าคงที่หลังดาว
และสิ่งนี้กำลังบอกว่าคุณไม่สามารถเปลี่ยนค่าของ
p-member ค่าของพอยน์เตอร์ ซึ่งเป็นแอดเดรสได้
แต่อีกครั้ง สิ่งนี้ไม่มีประโยชน์มากนัก เพราะเมื่อคุณส่งต่อค่า
คุณกำลังส่งสำเนาที่อยู่จริงๆ
ดังนั้นสิ่งนี้จึงซ้ำซ้อน คุณไม่จำเป็นต้องทำเช่นนี้ แต่คุณสามารถทำได้
และที่นี่ อีกครั้ง คุณต้องการเปลี่ยนที่อยู่ของสมาชิก p
และในกรณีนี้ คุณแค่เข้าถึงข้อมูลเพื่อดูว่ามันเท่ากันหรือไม่
ตัวดำเนินการทางอ้อมในการกำหนดพารามิเตอร์แต่ละรายการอยู่ข้างหน้าคีย์เวิร์ดคงที่
เครื่องหมายดอกจันนั้นไม่ได้อยู่หน้าชื่อพารามิเตอร์
คุณไม่สามารถแก้ไขที่อยู่ที่เก็บไว้ในพอยน์เตอร์ได้เนื่องจากอยู่หลังเครื่องหมายดอกจัน
หากอยู่ข้างหน้าประเภทชื่อพารามิเตอร์
คุณต้องการแก้ไขสิ่งที่ชี้ไปจริง
ถ้าเรามีโอเปอเรเตอร์ทางอ้อมหน้าชื่อพารามิเตอร์ ค่านั้นจะเป็นค่าคงที่ก่อนหน้านั้น
นั่นหมายความว่าคุณต้องการแก้ไขสิ่งที่ชี้ไป
นี่แค่บอกที่อยู่
ดังนั้นคุณจึงไม่สามารถแก้ไขที่อยู่ที่เก็บไว้ในพอยน์เตอร์ได้
มันคือพอยน์เตอร์ที่ได้รับการปกป้องที่นี่ ไม่ใช่โครงสร้างที่พวกเขาชี้ไป
เช่นเดียวกับพารามิเตอร์ค่าคงที่และพารามิเตอร์พอยน์เตอร์อื่นๆ ไม่มีความแตกต่างกับ struct
หากคุณต้องการส่งคืนโครงสร้างจากฟังก์ชันที่เป็นพอยน์เตอร์
ต้นแบบฟังก์ชันต้องระบุค่าที่ส่งกลับนี้ด้วยวิธีปกติในการประกาศ
ดังนั้นในที่นี้คุณจะต้องบอกว่าตัวชี้สนุกของฉันหรือไม่ตัวชี้ไม่สำคัญ
นี่คือต้นแบบสำหรับฟังก์ชันที่ไม่มีอาร์กิวเมนต์ที่ส่งกลับโครงสร้างของวันที่ประเภท
ง่ายต่อการส่งคืนโครงสร้างจากฟังก์ชัน และมูลค่าของสิ่งนี้คืออะไร
ตอนนี้ เราสามารถส่งคืนองค์ประกอบหรือรายการข้อมูลมากกว่าหนึ่งรายการจากฟังก์ชันได้
หากคุณกำลังส่งคืนโครงสร้าง คุณสามารถคืนค่า 10 ค่า รายการข้อมูลที่แตกต่างกัน 10 รายการ
เจ๋งแค่ไหน. struct อนุญาตให้คุณส่งคืนมากกว่าหนึ่งรายการจากฟังก์ชัน
คุ้มมาก.
ดังนั้นจึงสะดวกกว่าที่จะส่งคืนตัวชี้ไปยังโครงสร้างแทนที่จะเพียงแค่โครงสร้าง
เมื่อคุณส่งคืนตัวชี้ไปยังโครงสร้าง ตัวชี้จะถูกสร้างขึ้นบนฮีปเนื่องจากตัวชี้ทั้งหมดถูกสร้างขึ้นบนฮีป
ซึ่งหมายความว่าจะใช้เวลาประมาณอีกเล็กน้อย
และนี่หมายความว่าคุณสามารถลบและจัดการได้ตลอดเวลา
ในตัวอย่างนี้ เรากำลังสร้างโครงสร้างชื่อ fund
ประกอบด้วยอาร์เรย์อักขระชื่อธนาคาร
ประกอบด้วยอักขระสองตัว อักขระอื่นชื่อบันทึกความยาวเฉพาะ
สมมุติว่าความยาวความสนุกเท่ากับ 50
แล้วมีบันทึกสองครั้ง
เรามีฟังก์ชันที่เรียกว่า sum ซึ่งรับโครงสร้างนั้นเป็นพารามิเตอร์
และทั้งหมดที่เรากำลังทำอยู่ในนั้น คือ เรากำลังคืน
a - กองทุนธนาคารจากโครงสร้างแรก บวกกับกองทุนสำรอง และนั่นก็จะคืนจำนวนเงินที่พวกเขามีในธนาคาร
ในตัวอย่างนี้ ผลรวมเป็นเพียงสองเท่า
เราไม่ส่งคืนตัวชี้ เราแค่ใช้พอยน์เตอร์เป็นพารามิเตอร์
ดังนั้นในหน้าที่หลักของเรา เรากำลังสร้างตัวแปรโครงสร้างที่เรียกว่า
stan of type struct fund
เรากำลังเริ่มต้นใช้งานด้วยค่าบางอย่าง จากนั้นเราจะพิมพ์ยอดรวมการโทรออก
และเราก็แค่ส่งผ่านโครงสร้างนี้ เหมือนเราส่งผ่านตัวแปรใดๆ
เราไม่จำเป็นต้องยกเลิกการอ้างอิง มันไม่ใช่ตัวชี้ เราไม่ต้องทำอะไรเป็นพิเศษ
เราแค่ต้องแน่ใจว่าในการประกาศฟังก์ชัน เรามีประเภทโครงสร้างนั้นอยู่ที่นั่น
แต่อย่างอื่นดูปกติ
เตือนความจำสองสาม
ฉันได้กล่าวไว้ก่อนหน้านี้ว่าคุณควรใช้พอยน์เตอร์เมื่อส่งผ่านโครงสร้างไปยังฟังก์ชัน
ทำไม เพราะโปรดจำไว้ว่า c รุ่นเก่ากว่าไม่อนุญาตให้ส่งโครงสร้าง
แต่อนุญาตให้มีตัวชี้
ดังนั้นคุณจึงสามารถหลีกเลี่ยงความเข้ากันได้แบบย้อนหลังได้ทุกประเภท
หากคุณใช้ c เวอร์ชันเก่า โปรแกรมของคุณจะใช้งานได้
ดังนั้นเพียงแค่ส่งที่อยู่เดียวนั้นก็มีประสิทธิภาพมากกว่าเนื่องจากการคัดลอกเวลา
แต่ถ้าคุณทำเช่นนี้ หากคุณส่งผ่านพารามิเตอร์ที่เป็นตัวชี้ไปยังโครงสร้างภายในฟังก์ชัน
พารามิเตอร์นั้นจะมีการป้องกันข้อมูลของคุณน้อยกว่า
ดังนั้นการดำเนินการบางอย่างในฟังก์ชันที่เรียกอาจส่งผลต่อข้อมูลในโครงสร้างเดิมโดยไม่ได้ตั้งใจ
และนี่คือที่ที่คุณต้องการใช้ตัวระบุ const
และคุณจะต้องใช้ const ก่อนประเภทจริง
ไม่ใช่หลังเครื่องหมายดอกจันและก่อนชื่อพารามิเตอร์
ก่อนประเภท
ข้อดีของการส่งผ่านโครงสร้างคืออาร์กิวเมนต์ ฟังก์ชันทำงานร่วมกับสำเนาของข้อมูลต้นฉบับ
ปลอดภัยกว่าการทำงานกับข้อมูลเดิม
นั่นเป็นครั้งเดียวจริงๆ ที่คุณต้องการส่งผ่านโครงสร้างเป็นอาร์กิวเมนต์ที่ไม่ใช่ตัวชี้
และรูปแบบการเขียนโปรแกรมมีแนวโน้มที่จะชัดเจนขึ้นเล็กน้อย
ข้อเสียเปรียบหลักของการส่งผ่านโครงสร้างเป็นอาร์กิวเมนต์ ซึ่งตรงข้ามกับการส่งผ่านตัวชี้แบบมีโครงสร้างเนื่องจากอาร์กิวเมนต์เป็นการใช้งานแบบเก่าอาจไม่สามารถจัดการกับโค้ดได้
มันเสียเวลาและพื้นที่ และเป็นการสิ้นเปลืองโดยเฉพาะอย่างยิ่งเมื่อคุณมีโครงสร้างขนาดใหญ่ เราต้องทำสำเนาจำนวนมากสำหรับแต่ละรายการ สมาชิก.
ดังนั้นจงจำไว้
ส่วนใหญ่คุณต้องการส่งผ่านตัวชี้ไปยังโครงสร้าง
มีประสิทธิภาพมากขึ้นและประหยัดเวลา
โปรแกรมเมอร์ใช้ตัวชี้โครงสร้างเป็นอาร์กิวเมนต์ของฟังก์ชันด้วยเหตุผลด้านประสิทธิภาพ
และใช้ค่าคงที่เมื่อจำเป็น และนี่คือชุดค่าผสมที่คุณต้องการทำ
หากคุณกังวลเกี่ยวกับการป้องกัน เพียงใช้ตัวชี้ฟังก์ชันเพื่อประสิทธิภาพแล้วใช้
const const เพื่อไม่ให้มีอะไรเสียหายภายในฟังก์ชัน เช่นเดียวกับพอยน์เตอร์ทั่วไปจริงๆ
ไม่มากก็น้อย แต่สำหรับพอยน์เตอร์ ประสิทธิภาพนั้นสำคัญกว่าเพราะ ของโครงสร้างขนาดใหญ่
การส่งผ่านโครงสร้างตามค่ามักจะทำกับโครงสร้างที่มีขนาดเล็ก และนั่นเป็นกฎประเภทหนึ่งที่คุณต้องการนึกถึง
โอเคที่จะผ่านโครงสร้างที่ไม่ใช่ตัวชี้ตราบใดที่มันมีขนาดเล็ก
อีกครั้ง แนวคิดที่สำคัญบางอย่างที่เกี่ยวข้องกับโครงสร้างและพอยน์เตอร์ที่ส่งผ่านเป็นพารามิเตอร์
อาร์กิวเมนต์ และพอยน์เตอร์ที่ส่งกลับเช่นกัน
ตอนนี้
เราสามารถเริ่มใช้งานสิ่งนี้ได้จริง เราให้ตัวอย่างมากมาย เราเข้าใจแนวคิด เราเข้าใจไวยากรณ์
ตอนนี้ฉันต้องการนำเสนอความท้าทายสองสามอย่างที่คุณทำสิ่งนี้จริง ๆ คุณจำไวยากรณ์ได้หรือไม่ว่าตอนนี้ถ้าคุณต้องการสร้างโครงสร้างในโปรแกรม
คุณรู้วิธีการทำเหมือนหลังมือของคุณ
ดังนั้นเราจะมีความท้าทายสองสามอย่างในการบรรยายคู่ครั้งต่อไปของเราเพื่อให้คุณคุ้นเคยกับทุกสิ่งที่เราพูดถึงเกี่ยวกับโครงสร้าง
ขอขอบคุณ.