Dynamic Binding ใน C++: คำอธิบาย ฟังก์ชัน & Implementation

บทนำ

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

Dynamic Binding คืออะไร?

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

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

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

ฟังก์ชั่นเสมือน

เราได้พูดคุยเกี่ยวกับ การเชื่อมโยงแบบไดนามิกใน C ++ เป็นจำนวนมาก แต่จะทำอย่างไรต่อไป? ในการใช้การเชื่อมโยงแบบไดนามิกในโค้ด C++ ของคุณ คุณต้องใช้ 'ฟังก์ชันเสมือน' ฟังก์ชั่นเสมือนคืออะไร?

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

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

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

การใช้งาน C++

ที่เกี่ยวกับฟังก์ชันเสมือน ตอนนี้ให้เราดูโปรแกรมเพื่อทำความเข้าใจ การเชื่อมโยงแบบไดนามิกใน C++ :

โปรแกรม #1 :

เราเห็นสองคลาส:- คลาส A คือคลาส 'เบส' ในขณะที่คลาส B คือ 'คลาสที่ได้รับมา' ภายในทั้งสองคลาส มีฟังก์ชันเดียวที่มีชื่อ 'display' เหมือนกัน ในคลาสพาเรนต์ มีฟังก์ชันอื่นชื่อ final_print() เรียกฟังก์ชัน display() ในฟังก์ชัน main() เราสร้างอ็อบเจ็กต์ที่แตกต่างกันสองรายการสำหรับคลาสที่แตกต่างกันสองคลาส โดยเรียกใช้ฟังก์ชัน display() เดียวกัน

ให้เราดูผลลัพธ์ของโปรแกรมข้างต้น

ผลลัพธ์สำหรับโปรแกรม #1:

ตามที่คาดไว้ เอาต์พุตจะเรียกใช้ฟังก์ชัน display() ของคลาสฐานสองครั้งตามที่กำหนดไว้ ณ เวลารวบรวม (การโยงแบบคงที่) แต่นี่ไม่ใช่ผลลัพธ์ที่เราต้องการ

ในการแปลงโค้ดด้านบนเป็นไดนามิกโยง เราจำเป็นต้องใช้ฟังก์ชันเสมือน เรามาดูวิธีการทำกัน

โปรแกรม #2:

เราเพียงแค่เพิ่มคำหลัก 'เสมือน' สำหรับฟังก์ชัน display() ทั้งสองของเราใน Class A และ Class B ซึ่งทำให้เป็นฟังก์ชันเสมือน นั่นคือการเปลี่ยนแปลงเพียงอย่างเดียวที่จำเป็น เหมือนกับเมื่อก่อน เราเรียกใช้ฟังก์ชัน final_print() เดียวกันโดยใช้สองอ็อบเจ็กต์ที่แตกต่างกัน ให้เราดูว่าเราได้ผลลัพธ์อะไรในตอนนี้

ผลลัพธ์สำหรับโปรแกรม #2 :

นี่คือผลลัพธ์ที่เราต้องการ และเราได้มันมาโดยใช้การเชื่อมโยงแบบไดนามิกของฟังก์ชัน

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

บทสรุป

ในบทความนี้ เราได้กล่าวถึงแนวคิดของ การโยงไดนามิกใน C ++ สรุปได้ว่าการเชื่อมโยงแบบไดนามิกช่วยให้เรามีความยืดหยุ่นโดยการเรียกใช้ฟังก์ชันเดียวเพื่อจัดการกับวัตถุต่างๆ ดังที่เห็นได้ชัดจากโค้ดของเรา เราเรียกฟังก์ชันเดียวกัน display() โดยสร้างอ็อบเจ็กต์ที่แตกต่างกันสองรายการเพื่อให้เอาต์พุตต่างกันสองรายการ สิ่งนี้เป็นไปได้เนื่องจากการโยงไดนามิกเกิดขึ้นที่รันไทม์ ซึ่งแตกต่างจากการโยงแบบสแตติกที่เกิดขึ้นในเวลาคอมไพล์

หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับการพัฒนาแบบฟูลสแตก โปรดดูโปรแกรม Executive PG ของ upGrad & IIIT-B ในการพัฒนาซอฟต์แวร์ฟูลสแตก ซึ่งออกแบบมาสำหรับมืออาชีพที่ทำงานและมีการฝึกอบรมที่เข้มงวดมากกว่า 500 ชั่วโมง โครงการและการมอบหมายมากกว่า 9 รายการ , สถานะศิษย์เก่า IIIT-B, โครงการหลักที่นำไปปฏิบัติได้จริง & ความช่วยเหลือด้านงานกับบริษัทชั้นนำ