อย่างไรก็ตาม ตัวทำลายเสมือนอาจมีอยู่จริง ที่นี่ เราจะแสดงสิ่งที่เกิดขึ้นเมื่อเราสร้างตัวสร้างเสมือนใน C++ รวมถึงการทำงานของตัวทำลายเสมือนแทนตัวสร้างเสมือน
ตัวอย่างที่ 1:
มาสร้างคอนสตรัคเตอร์เสมือนและเริ่มโค้ดของเราโดยวางไฟล์ส่วนหัว 'iostream' ไฟล์ส่วนหัวนี้ใช้สำหรับฟังก์ชันที่ประกาศไว้เช่น 'cin' และ 'cout' หลังจากนี้ เราจะเพิ่มเนมสเปซ 'std' ดังนั้นเราจึงไม่สามารถเพิ่ม 'std' นี้กับทุกฟังก์ชันในโค้ดของเราได้ หลังจากนี้ เราจะสร้างคลาสซึ่งเป็นคลาสพื้นฐานของโค้ดของเราโดยใช้ชื่อ “my_base” จากนั้นจึงเพิ่ม “public” เพื่อสร้างคอนสตรัคเตอร์เสมือน
ตัวสร้างเสมือนถูกสร้างขึ้นที่นี่โดยการวางคีย์เวิร์ด 'เสมือน' ภายใน Constructor เสมือนนี้ เราใส่คำสั่ง 'cout' ด้านล่างนี้ เราสร้างฟังก์ชันชื่อ 'show' ซึ่งเราใช้ 'cout' อีกครั้ง หลังจากนี้ เราจะสร้างคลาสที่ได้รับมาจากคลาสพื้นฐานนี้ด้วยชื่อ 'my_derived' จากนั้นจึงสร้างคอนสตรัคเตอร์ 'my_derived()' ในช่อง 'public' เราแทรกคำสั่ง “cout” ลงใน Constructor “my_derived()” นี้ ด้านล่างนี้ เราสร้างฟังก์ชันที่เรียกว่า 'show' ซึ่งเราใช้ 'cout' อีกครั้ง
ตอนนี้หลังจากเรียกใช้ 'main()' แล้ว เราก็สร้างพอยน์เตอร์ของคลาสพื้นฐานด้วยชื่อ 'my_ptr' และยังสร้างอ็อบเจ็กต์ของคลาสที่ได้รับซึ่งก็คือ 'Obj_d' หลังจากนี้ เราจะกำหนดที่อยู่ของ “Obj_d” ให้กับ “my_ptr” จากนั้นเราเรียกฟังก์ชัน 'show()' ผ่าน 'my_ptr'
รหัส 1:
#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;
ระดับ my_base
{
สาธารณะ : :
เสมือน my_base ( )
{
ศาล << “นี่คือคลาสพื้นฐานของฉัน” << สิ้นสุด ;
}
เป็นโมฆะ แสดง ( )
{
ศาล << 'ฟังก์ชั่นการแสดงของคลาสพื้นฐาน' << สิ้นสุด ;
}
} ;
ระดับ my_derived : : สาธารณะ my_base
{
สาธารณะ : :
my_derived ( )
{
ศาล << “นี่คือคลาสที่ได้รับของฉัน” << สิ้นสุด ;
}
เป็นโมฆะ แสดง ( )
{
ศาล << 'ฟังก์ชันการแสดงของคลาสที่ได้รับ' < แสดง ( ) ;
}
เอาท์พุท:
ที่นี่จะแสดงข้อความแสดงข้อผิดพลาดที่ระบุว่าไม่สามารถประกาศตัวสร้างเสมือนในการเขียนโปรแกรม C++ ดังนั้นเราจะเห็นได้ว่า C++ ไม่อนุญาตให้เราสร้างตัวสร้างเสมือน แต่เราอาจสร้างตัวทำลายเสมือนได้
ตัวอย่างที่ 2:
มาแก้ไขปัญหาก่อนหน้านี้และสร้างตัวทำลายเสมือนในโค้ดนี้ หลังจากประกาศคลาส 'new_base' เราจะวางคอนสตรัคเตอร์ 'สาธารณะ' ที่เราสร้างตัวทำลายเสมือนโดยเพิ่ม 'virtual ~' ด้วย 'new_base' เราแทรกคำสั่ง 'cout' ลงในตัวทำลายเสมือนนี้ ด้านล่างนี้ เราสร้างฟังก์ชันที่เรียกว่า 'show' ซึ่งใช้ 'cout' ต่อไป เราสร้างคลาสที่ได้รับซึ่งก็คือ 'new_derived' ของคลาสพื้นฐาน 'new_base' นี้ และสร้างตัวทำลาย 'new_derived()' ในช่อง 'public' ตอนนี้ตัวทำลาย 'new_derived()' มีคำสั่ง 'cout' เพิ่มเข้าไปแล้ว
ด้านล่างนี้เราสร้างฟังก์ชันที่เรียกว่า 'show' ซึ่งใช้คำสั่ง 'cout' อีกครั้ง หลังจากเรียกใช้ฟังก์ชัน 'main()' แล้ว ตอนนี้เราสร้างอ็อบเจ็กต์ของคลาสที่ได้รับ 'obj_d' รวมถึงตัวชี้ของคลาสพื้นฐานที่ชื่อว่า 'ptr1' หลังจากนั้นเราจะให้ที่อยู่ 'obj_d' แก่ 'ptr1' จากนั้นจึงเรียกใช้เมธอด 'show()' โดยใช้ 'ptr1'
รหัส 2:
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
ระดับ ใหม่_ฐาน
{
สาธารณะ : :
เสมือน ~new_base ( )
{
ศาล << “ผู้ทำลายล้างคลาสพื้นฐานอยู่ที่นี่” << สิ้นสุด ;
}
เป็นโมฆะ แสดง ( )
{
ศาล << 'ฟังก์ชั่นการแสดงของคลาสพื้นฐาน' << สิ้นสุด ;
}
} ;
ระดับ ใหม่_ได้มา : : สาธารณะ ใหม่_ฐาน
{
สาธารณะ : :
~new_derived ( )
{
ศาล << “ตัวทำลายคลาสที่ได้รับมาอยู่ที่นี่” << สิ้นสุด ;
}
เป็นโมฆะ แสดง ( )
{
ศาล << 'ฟังก์ชั่นการแสดงของคลาสพื้นฐาน' < แสดง ( ) ;
}
เอาท์พุท:
โปรแกรมนี้ใช้วัตถุตัวชี้ของ 'new_base' ที่ชี้ไปที่คลาสที่ได้รับ 'obj_d' ดังนั้นจึงเรียกเมธอด 'show()' ของคลาส 'new_base' ก่อน จากนั้นจะเรียกเมธอด “~new_derived()” ของคลาส “new_derived” และแสดง “~new_base” ของคลาสพื้นฐาน
ตัวอย่างที่ 3:
นี่เป็นอีกโค้ดหนึ่งสำหรับสร้างคอนสตรัคเตอร์ 'เสมือน' หลังจากรวมเนมสเปซ “iostream” และ “std” แล้ว เราจะสร้างคลาส “B” ด้านล่างนี้ เราสร้างคอนสตรัคเตอร์ 'สาธารณะ' ซึ่งก็คือ 'B()' จากนั้นจึงสร้าง 'cout' ฟังก์ชัน Constructor และ Destructor ถูกกำหนดโดยใช้ตัวระบุการเข้าถึง 'สาธารณะ' ซึ่งอ็อบเจ็กต์ใดๆ ในคลาสสามารถเรียกใช้ได้
ตอนนี้เรายังสร้างตัวทำลาย '~B()' ของคลาสพื้นฐานนี้ซึ่งเราใช้ 'cout' อีกครั้ง จากนั้นเราสร้างคลาส 'D' ซึ่งเป็นคลาสที่ได้รับมาจากคลาสพื้นฐาน 'B' และวาง 'สาธารณะ' ไว้ที่นี่ ภายใน 'สาธารณะ' นี้ เราสร้างตัวสร้างและตัวทำลายของคลาสที่ได้รับโดยใช้ชื่อ 'D()' และ '~D' ตามลำดับ ทั้งสองมี 'cout' อยู่ข้างใน ตอนนี้เรามีฟังก์ชัน 'main()' แล้ว หลังจากเรียกใช้ฟังก์ชันนี้แล้ว เราจะสร้างวัตถุตัวชี้ของคลาสพื้นฐาน
จากนั้นเราใช้คำหลัก 'ลบ' และวาง 'base_ptr' ที่นี่ ในกรณีนี้ พื้นที่ของ destructor จะถูกลบโดยการเรียกอ็อบเจ็กต์ตัวชี้ของคลาสพื้นฐาน
รหัส 3:
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
ระดับ บี
{
สาธารณะ : :
บี ( )
{
ศาล << 'ตัวสร้างคลาสฐาน' << สิ้นสุด ;
}
~บี ( )
{
ศาล << 'ผู้ทำลายล้างของคลาสฐาน' << สิ้นสุด ;
}
} ;
ระดับ ดี : : สาธารณะ บี
{
สาธารณะ : :
ดี ( )
{
ศาล << 'ตัวสร้างคลาสสืบทอด' << สิ้นสุด ;
}
~ด ( )
{
ศาล << 'ผู้ทำลายล้างของคลาสสืบทอด' << สิ้นสุด ;
}
} ;
ภายใน หลัก ( )
{
บี * base_ptr = ใหม่ ดี ;
ลบ base_ptr ;
}
เอาท์พุท:
ผลลัพธ์แสดงให้เห็นว่าใช้วัตถุตัวชี้ที่ชี้ไปที่คลาส 'B' ในฟังก์ชันหลัก ดังนั้นจึงเรียก 'constructor()' ของคลาส 'B' ก่อน จากนั้นจะเรียก 'constructor()' ของคลาส 'D' วัตถุตัวชี้ที่ถือโดย destructors ของคลาส 'B' และ 'D' จะถูกลบออก โดยไม่ต้องเรียกใช้ตัวทำลายของคลาส “D” ภายในโปรแกรม ตัวชี้คลาส “B” จะกำจัดเฉพาะตัวทำลายของคลาส “B” เท่านั้น ส่งผลให้หน่วยความจำของโปรแกรมเสียหาย
บทสรุป
เราได้พูดคุยถึงแนวคิดของ 'การสร้างเสมือนจริง' ในการเขียนโปรแกรม C++ เราสำรวจแล้วว่าเราไม่สามารถสร้างตัวสร้างเสมือนใน C ++ ได้ แต่เราอาจสร้างตัวทำลายเสมือนในโค้ดของเรา ที่นี่ เราแสดงให้เห็นสิ่งที่เกิดขึ้นเมื่อเราสร้างตัวสร้างเสมือนในการเขียนโปรแกรม C++ และการทำงานของตัวทำลายเสมือนในโค้ดของเรา เราเรียนรู้ว่าตัวสร้างไม่สามารถเป็นเสมือนได้ แต่เราสามารถสร้างตัวทำลายเสมือนในชั้นเรียนของเราได้ เราได้สาธิตตัวอย่างและอธิบายโค้ดเหล่านี้อย่างละเอียดในคู่มือนี้