วิธีการใช้งานฟังก์ชันเสมือนใน C ++

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

• Virtual Function คืออะไร?
• กฎสำหรับฟังก์ชันเสมือนใน C ++
• Binding คืออะไร?
• ผูกพันในช่วงต้น
• ผลผูกพันล่าช้า
• ฟังก์ชั่นเสมือนจริง
• คลาสนามธรรม
• ตัวอย่างสำหรับฟังก์ชันเสมือน

ดังนั้นให้เราเริ่มต้นด้วยบทความนี้เกี่ยวกับฟังก์ชันเสมือนใน C ++

Virtual Function คืออะไร?

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

ไปต่อกับบทความนี้เกี่ยวกับฟังก์ชันเสมือนใน C ++

กฎสำหรับฟังก์ชันเสมือนใน C ++:

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

ไปต่อกับบทความนี้เกี่ยวกับฟังก์ชันเสมือนใน C ++

วิธีการแปลง double เป็น int ใน java

การผูกมัดคืออะไร?

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

ไปต่อกับบทความนี้เกี่ยวกับฟังก์ชันเสมือนใน C ++

ผูกพันในช่วงต้น

การเชื่อมโยงก่อนกำหนดเป็นปรากฏการณ์ที่การตัดสินใจจับคู่การเรียกใช้ฟังก์ชันต่างๆเกิดขึ้นในเวลาคอมไพล์เองและคอมไพเลอร์เชื่อมโยงลิงก์กับแอดเดรสโดยตรง เป็นที่รู้จักกันในชื่อ Static Binding หรือ Compile-time Binding

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

ตัวอย่าง

#include ใช้เนมสเปซคลาส std สัตว์ {public: void sound () {cout<< 'Genric animal sound' << endl } } class Cats: public Animals { public: void sound() { cout << 'Cat meow' <เสียง () // ผลตอบแทนการผูกก่อน 0}

เอาต์พุต

คำชี้แจง ไอออน
ในตัวอย่างนี้เราได้สร้างตัวชี้ a ไปยังคลาสแม่สัตว์ จากนั้นด้วยการเขียน a = & c ตัวชี้ 'a' จะเริ่มอ้างถึงวัตถุ c ของคลาส Cats
a -> sound () - ในการเรียกฟังก์ชัน sound () ซึ่งมีอยู่ในคลาสทั้งสองโดยตัวชี้ 'a' ฟังก์ชันของคลาสพาเรนต์จะถูกเรียกแม้ว่าตัวชี้จะอ้างถึงอ็อบเจ็กต์ของคลาส Cats .

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

ไปต่อกับบทความนี้เกี่ยวกับฟังก์ชันเสมือนใน C ++

การผูกมัดล่าช้า

ในการเชื่อมต่อท้ายคอมไพลเลอร์ระบุอ็อบเจ็กต์ที่รันไทม์จากนั้นจับคู่การเรียกใช้ฟังก์ชันกับฟังก์ชันที่ถูกต้อง เป็นที่รู้จักกันในชื่อ Dynamic Binding หรือ Runtime Binding

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

ตัวอย่าง

#include ใช้เนมสเปซคลาส std สัตว์ {public: virtual void sound () {cout<< 'Genric aniaml sound' << endl } } class Cats: public Animals { public: void sound() { cout << 'Cats meow' <เสียง () ส่งกลับ 0}

เอาต์พุต

คำอธิบาย
ที่นี่ฟังก์ชั่นเสียง () ของคลาสพื้นฐานถูกสร้างขึ้นเสมือนดังนั้นคอมไพเลอร์ในขณะนี้ดำเนินการโยงสายสำหรับฟังก์ชันนี้ ตอนนี้การเรียกใช้ฟังก์ชันของฟังก์ชัน sound () จะถูกจับคู่กับนิยามฟังก์ชันที่รันไทม์ เนื่องจากขณะนี้คอมไพเลอร์ระบุตัวชี้ 'a' ที่อ้างถึงอ็อบเจ็กต์ 'c' ของคลาสที่ได้รับ Cats มันจะเรียกใช้ฟังก์ชัน sound () ของคลาส Cats

ไปต่อกับบทความนี้เกี่ยวกับฟังก์ชันเสมือนใน C ++

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

ฟังก์ชันเสมือนจริงใน C ++ เป็นฟังก์ชันเสมือนจริงที่เราไม่มีการใช้งานเราเพียง แต่ประกาศเท่านั้น ฟังก์ชันเสมือนจริงถูกประกาศโดยการกำหนด 0 ในการประกาศ

เสียงโมฆะเสมือน () = 0

ที่นี่เสียง () เป็น fuction เสมือนจริง

ไปต่อกับบทความนี้เกี่ยวกับฟังก์ชันเสมือนใน C ++

คลาสนามธรรม

คลาสนามธรรมถูกกำหนดให้เป็นคลาสที่มีฟังก์ชันเสมือนจริงอย่างน้อยหนึ่งฟังก์ชัน ตามที่อธิบายไว้ข้างต้นฟังก์ชันเสมือนจริงคือฟังก์ชันสมาชิกเสมือนที่ถูกทำเครื่องหมายว่าไม่มีการใช้งาน ไม่มีการนำไปใช้กับข้อมูลที่ให้ไว้ในชั้นเรียนรวมถึงคลาสพื้นฐานใด ๆ คลาสนามธรรมเรียกอีกอย่างว่าคลาสฐานนามธรรม

ตัวอย่าง

#include using namespace std class Employee // abstract base class {virtual int getSalary () = 0 // pure virtual function} class Employee_1: public Employee {int เงินเดือน public: Employee_1 (int s) {เงินเดือน = s} int getSalary () {return เงินเดือน}} class Employee_2: public Employee {int เงินเดือน public: Employee_2 (int t) {เงินเดือน = t} int getSalary () {return เงินเดือน}} int main () {Employee_1 e1 (5000) Employee_2 e2 (3000) int a, ba = e1.getSalary () b = e2.getSalary () cout<< 'Salary of Developer : ' << a << endl cout << 'Salary of Driver : ' << b << endl return 0 } 

เอาต์พุต

โปรแกรม fibonacci series ใน java

คำอธิบาย
ฟังก์ชัน 'getSalary ()' ในคลาส Employee เป็นฟังก์ชันเสมือนจริง เนื่องจากคลาส Employee มีฟังก์ชันเสมือนจริงดังนั้นจึงเป็นคลาสพื้นฐานที่เป็นนามธรรม
เนื่องจากฟังก์ชันเสมือนจริงถูกกำหนดไว้ในคลาสย่อยดังนั้นฟังก์ชัน 'getSalary ()' จึงถูกกำหนดทั้งในคลาสย่อยของคลาส Employee เช่นใน Employee_1 และ Employee_2

ไปต่อกับบทความนี้เกี่ยวกับฟังก์ชันเสมือนใน C ++

ตัวอย่างสำหรับฟังก์ชันเสมือน

#include โดยใช้ namespace std class base {public: void function_1 () {cout<< 'base class function 1n' } virtual void function_2() { cout << 'base class function 2n' } virtual void function_3() { cout << 'base class function 3n' } virtual void function_4() { cout << 'base class function 4n' } } class derived : public base { public: void function_1() { cout << 'derived class function 1n' } void function_2() { cout << 'derived class function 2n' } void function_4(int x) { cout function_2 () ptr-> function_3 () ptr-> function_4 ()}

เอาต์พุต

คำอธิบาย
สำหรับการเรียกใช้ฟังก์ชัน function_1 () ฟังก์ชันเวอร์ชันพื้นฐานจะถูกเรียกใช้ฟังก์ชัน_2 () ถูกแทนที่ในคลาสที่ได้รับดังนั้นจึงเรียกเวอร์ชันคลาสที่ได้รับมาฟังก์ชัน_3 () จะไม่ถูกแทนที่ในคลาสที่ได้รับและเป็นฟังก์ชันเสมือนดังนั้นเวอร์ชันคลาสพื้นฐานจึงถูกเรียกว่า ในทำนองเดียวกัน function_4 () ไม่ถูกแทนที่ดังนั้นจึงเรียกเวอร์ชันคลาสพื้นฐาน

ดังนั้นเราจึงมาถึงตอนท้ายของบทความนี้เกี่ยวกับ 'Virtual Function in C ++' หากคุณต้องการเรียนรู้เพิ่มเติมโปรดดูไฟล์ โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ หลักสูตรการฝึกอบรมและการรับรอง Java J2EE และ SOA ของ Edureka ได้รับการออกแบบมาเพื่อฝึกอบรมคุณสำหรับแนวคิด Java ทั้งหลักและขั้นสูงพร้อมกับกรอบงาน Java ต่างๆเช่น Hibernate & Spring

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