เนื้อหา

• แผนภูมิเปรียบเทียบ:
• คำจำกัดความของตัวสร้าง:
• ประเภทของการก่อสร้าง
• การดำเนินการของคอนสตรัค:
• คำจำกัดความของ Destructor:
• การใช้งาน Destructor:
• ต้องการนักทำลายล้าง
• สรุป:

ตัวสร้างและ destructor เป็นฟังก์ชันสมาชิกที่มีชื่อเดียวกันกับคลาสของพวกเขา ประเภทเดิม นวกรรมิก ช่วยในการเริ่มต้นวัตถุ ในทางกลับกัน destructor แตกต่างจากนวกรรมิกซึ่งจะลบนวกรรมิกที่สร้างขึ้นเมื่อไม่มีการใช้งาน

บางครั้งจำเป็นต้องเริ่มต้นบางส่วนของวัตถุก่อนที่จะสามารถใช้งานได้ ตัวอย่างเช่นเรากำลังดำเนินการกับสแต็กก่อนที่เราจะดำเนินการใด ๆ ด้านบนของสแต็กจะต้องตั้งค่าเป็นศูนย์เสมอ คุณลักษณะของการเริ่มต้นอัตโนมัตินี้ดำเนินการผ่าน 'Constructor' เช่นถ้าวัตถุต้องการรันโค้ดบางอย่างก่อนที่มันจะถูกทำลาย ตัวอย่างเช่นหากวัตถุต้องการปิดไฟล์ที่เปิดไว้ก่อนที่จะถูกทำลาย สามารถดำเนินการได้ด้วยความช่วยเหลือของ 'Destructor'

ให้ภาพรวมของความแตกต่างพื้นฐานบางอย่างระหว่างตัวสร้างและ destructor ด้วยความช่วยเหลือของแผนภูมิเปรียบเทียบ

1. แผนภูมิเปรียบเทียบ
2. คำนิยาม
3. ความแตกต่างที่สำคัญ
4. ข้อสรุป

แผนภูมิเปรียบเทียบ:

พื้นฐานสำหรับการเปรียบเทียบ	นวกรรมิก	destructor
วัตถุประสงค์	มันจัดสรรหน่วยความจำไปยังวัตถุ	มันยกเลิกการจัดสรรหน่วยความจำของวัตถุ
การประกาศ	class_name (อาร์กิวเมนต์ถ้ามี) {};	~ class_name (ไม่มีอาร์กิวเมนต์) {};
ข้อโต้แย้ง	ตัวสร้างยอมรับอาร์กิวเมนต์	Destructor ไม่ยอมรับอาร์กิวเมนต์ใด ๆ
การเรียกร้อง	ตัวสร้างถูกเรียกโดยอัตโนมัติในขณะที่วัตถุถูกสร้างขึ้น	Destructor ถูกเรียกโดยอัตโนมัติเมื่อบล็อกถูกออกหรือโปรแกรมสิ้นสุดลง
การทำงาน	ตัวสร้างอนุญาตให้วัตถุเริ่มต้นค่าบางอย่างก่อนที่จะใช้	Destructor อนุญาตให้วัตถุรันโค้ดบางอย่างในเวลาที่ถูกทำลาย
คำสั่งของการดำเนินการ	ตัวสร้างถูกเรียกตามลำดับอย่างต่อเนื่อง	Destructor ถูกเรียกตามลำดับตัวสร้างแบบย้อนกลับ
เป็นตัวเลข	สามารถมีหลาย constructors ในชั้นเรียน	มี destructor เดียวในชั้นเรียนเสมอ
คัดลอกตัวสร้าง	ตัวสร้างการคัดลอกอนุญาตให้ตัวสร้างการประกาศและเตรียมใช้งานวัตถุจากวัตถุอื่น	ไม่มีแนวคิดดังกล่าว
โหลดมากกว่า	ตัวสร้างสามารถโอเวอร์โหลดได้	Destructor ไม่สามารถโหลดได้มากเกินไป

คำจำกัดความของตัวสร้าง:

นวกรรมิก นั้นเป็นฟังก์ชันสมาชิกของคลาสซึ่งเริ่มต้นวัตถุและจัดสรรหน่วยความจำให้กับมัน คอนสตรัคเตอร์สามารถระบุได้ง่าย ๆ ตามที่มีการประกาศและกำหนดด้วยชื่อเดียวกันกับคลาส คอนสตรัคไม่มีประเภทผลตอบแทนใด ๆ ดังนั้นพวกเขาจะไม่คืนสิ่งใดเลยแม้แต่ 'โมฆะ' ตัวสร้างถูกกำหนดไว้เสมอในส่วนสาธารณะของชั้นเรียน

สามารถมีหลาย constructors ในชั้นเรียน สามารถแยกได้ตามจำนวนและชนิดของอาร์กิวเมนต์ที่ส่งผ่าน หากมีคอนสตรัคเตอร์หลายตัวในคลาส Constructor (Constructor Do-nothing Constructor) ต้องถูกกำหนดพร้อมกับพวกมัน มันไม่ทำอะไรเลยนอกจากคอมไพเลอร์เป็นที่น่าพอใจ

คอนสตรัคเตอร์ยังสามารถกำหนดด้วยอาร์กิวเมนต์เริ่มต้น ในขณะที่พวกเขายังเริ่มต้นวัตถุ "แบบไดนามิก" คอนสตรัคเตอร์ไม่สามารถสืบทอดและไม่สามารถเป็นเสมือนได้ แต่สามารถโอเวอร์โหลดได้ พวกเขาไม่สามารถอ้างถึงที่อยู่ของพวกเขาได้

ประเภทของการก่อสร้าง

โดยทั่วไปมีสามประเภทของการก่อสร้าง - เริ่มต้น, พารามิเตอร์และคัดลอกก่อสร้าง

• ตัวสร้างเริ่มต้น: มันเป็นนวกรรมิกที่ไม่มีการโต้แย้งใด ๆ ตัวสร้างเริ่มต้นไม่มีพารามิเตอร์ แต่ค่าไปยังตัวสร้างเริ่มต้นสามารถส่งผ่านโดยค่าเริ่มต้น (แบบไดนามิก)
• ตัวสร้างพารามิเตอร์: คอนสตรัคเตอร์ประเภทนี้รับอาร์กิวเมนต์; เราสามารถส่งค่าที่แตกต่างไปยังสมาชิกข้อมูลเป็นอาร์กิวเมนต์
• คัดลอกตัวสร้าง: ตัวสร้างการคัดลอกแตกต่างจากตัวสร้างชนิดอื่นเนื่องจากยอมรับที่อยู่ของวัตถุอื่นเป็นอาร์กิวเมนต์

การดำเนินการของคอนสตรัค:

คลาส Const {int a, b; สาธารณะ: Const () // คอนสตรัคโดยไม่มีพารามิเตอร์ {a = 0; ข = 0; } Const (int c, int d) {// คอนสตรัคเตอร์ที่มีพารามิเตอร์ a = c; c = d; }}; int main () {Const C1; C2 (10,20); // คำสั่งนี้เรียกใช้ constructor}

เมื่อ C1 ถูกสร้างคอนสตรัคเตอร์โดยไม่มีพารามิเตอร์จะถูกดำเนินการเนื่องจาก C1 ไม่ผ่านพารามิเตอร์ใด ๆ ในขณะที่เมื่อ C2 ถูกสร้างตัวสร้างด้วยพารามิเตอร์จะได้รับการดำเนินการตามที่มันผ่านสองจำนวนเต็มไปที่ตัวสร้าง

คำจำกัดความของ Destructor:

destructor ยังเป็นฟังก์ชันสมาชิกของคลาสซึ่ง deallocates หน่วยความจำที่จัดสรรให้กับวัตถุ มันถูกกำหนดด้วยชื่อเดียวกันกับของคลาสนำหน้าด้วย ตัวหนอน (~) สัญลักษณ์. Destructors จะเรียกตามลำดับย้อนหลังของตัวสร้างเสมอ

มี destructor เดียวในคลาสเสมอเนื่องจากไม่ยอมรับอาร์กิวเมนต์ใด ๆ วัตถุในท้องถิ่นจะถูกทำลายทันทีที่การควบคุมของการดำเนินการทำให้บล็อกหลุด ในทางกลับกันวัตถุโกลบอลจะถูกทำลายเมื่อโปรแกรมทั้งหมดสิ้นสุดลง ตัวทำลายถูกเรียกโดยคอมไพเลอร์ หากคลาสนั้นได้รับการสืบทอดและคลาสนั้นได้มาจากคลาสแม่และทั้งคลาสลูกและคลาสแม่นั้นมี destructors จากนั้น destructor ของคลาสที่ได้รับจะถูกเรียกก่อนตามด้วย destructor ของคลาสพาเรนต์

การใช้งาน Destructor:

คลาส Const {int a, b; สาธารณะ: Const (int c, int d) // คอนสตรัคกับพารามิเตอร์ {a = c; c = d; ศาล << "ค่าของ a และ b คือ" <<>

เมื่อสร้างวัตถุ C1 ตัวสร้างที่มีพารามิเตอร์จำนวนเต็มสองชนิดจะถูกเรียกใช้และสมาชิก“ a, b” จะได้รับการกำหนดค่าเริ่มต้นและค่าของ“ a, b” นั้นเป็น ed หลังจาก destructor นั้นถูกเรียกใช้และ s“ object C1 get destroy”

ต้องการนักทำลายล้าง

การสร้างคอนสตรัคเตอร์ใช้พื้นที่หน่วยความจำจำนวนหนึ่งเนื่องจากท้ายที่สุดจะจัดสรรหน่วยความจำให้กับวัตถุ หน่วยความจำที่จัดสรรนี้จะต้องถูกจัดสรรคืนก่อนที่จะทำลายวัตถุเพื่อเพิ่มทรัพยากรสำหรับงานอื่น ๆ Destructors มีประโยชน์อย่างยิ่งสำหรับจุดประสงค์ที่ตั้งใจไว้ซึ่งจะทำลายวัตถุได้อย่างมีประสิทธิภาพและดำเนินงานการล้างข้อมูลเพื่อปล่อยหน่วยความจำ

1. วัตถุประสงค์หลักของตัวสร้างคือการจัดสรรหน่วยความจำให้กับวัตถุเมื่อพวกเขาถูกสร้างขึ้น ตรงกันข้ามกับวัตถุประสงค์หลักของ destructor คือการจัดสรรคืนความทรงจำของวัตถุเมื่อมันถูกทำลาย
2. ตัวสร้างได้รับอนุญาตให้ยอมรับข้อโต้แย้งเป็นข้อโต้แย้งที่สามารถใช้ในการเริ่มต้นสมาชิกข้อมูลของชั้นเรียน ในทางตรงกันข้ามผู้ทำลายระบบไม่ยอมรับข้อโต้แย้งใด ๆ เนื่องจากงานเพียงอย่างเดียวคือการจัดสรรคืนหน่วยความจำของวัตถุ
3. คอนสตรัคถูกเรียกเมื่อวัตถุถูกสร้างขึ้น ในทางตรงกันข้าม destructor จะถูกเรียกเมื่อโปรแกรมถูกยกเลิกหรือโปรแกรมออกจากบล็อกที่วัตถุถูกสร้างขึ้น
4. คอนสตรัคเตอร์โดยทั่วไปจะใช้ในการเริ่มต้นข้อมูลสมาชิกของคลาสในขณะที่ destructor จะใช้เพื่อให้วัตถุดำเนินการบางอย่างก่อนที่มันจะถูกทำลาย
5. คอนสตรัคเตอร์จะถูกดำเนินการตามลำดับที่ต่อเนื่องซึ่งหมายความว่าหากมีคลาสที่ได้รับซึ่งสืบทอดคลาสฐานและวัตถุของคลาสที่ได้รับนั้นถูกสร้างขึ้นมันจะเรียกคอนสตรัคเตอร์ของคลาสพื้นฐานก่อนจากนั้นตัวสร้างของคลาสที่ได้รับ ในทางกลับกัน destructor ของคลาสที่ได้รับนั้นถูกเรียกว่าอันดับแรกจากนั้นคลาสฐานก็หมายความว่าตัวดำเนินการ destructor จะดำเนินการในลำดับที่กลับกันของตัวสร้าง
6. ในชั้นเรียนสามารถมีหลายสิ่งก่อสร้างที่ระบุโดยอาร์กิวเมนต์จำนวนที่ส่งผ่านในขณะที่มันสามารถมีเพียงหนึ่ง destructor
7. มีแนวคิดของตัวสร้างสำเนาซึ่งอนุญาตให้วัตถุเริ่มต้นจากวัตถุอื่นได้ในขณะที่ destructor ไม่มีแนวคิดดังกล่าว
8. คอนสตรัคเตอร์สามารถโอเวอร์โหลดเพื่อดำเนินการต่าง ๆ ภายใต้ชื่อของคอนสตรัคเตอร์เดียวกัน ในทางตรงกันข้าม destructors ไม่สามารถมากเกินไป

สรุป:

นอกจากความคล้ายคลึงกันคอนสตรัคเตอร์และ destructor นั้นเป็นฟังก์ชันสมาชิกพิเศษของคลาสและมีชื่อเดียวกันความแตกต่างที่สำคัญระหว่างทั้งสองคือ 'คอนสตรัคเตอร์' ถูกเรียกในเวลาของการจัดสรรหน่วยความจำและ 'destructor' ถูกเรียก เวลาของการจัดสรรคืนหน่วยความจำวัตถุ คอนสตรัคเตอร์และคอนสตรัคเตอร์ถูกเรียกโดยปริยายโดยคอมไพเลอร์แม้ว่าจะไม่ได้กำหนดไว้ในคลาส