แนะนำ, 2024

ตัวเลือกของบรรณาธิการ

ความแตกต่างระหว่างฟังก์ชั่นการบรรทุกเกินพิกัดและการเอาชนะใน C ++

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

นอกจากนี้เราศึกษาความแตกต่างระหว่างการบรรทุกเกินพิกัดและการเอาชนะด้วยความช่วยเหลือของกราฟเปรียบเทียบ


ตารางเปรียบเทียบ:

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

คำจำกัดความของการบรรทุกเกินพิกัด

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

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

การใช้งานของการโอเวอร์โหลดใน C ++

 คลาสเกินพิกัด {int a, b; สาธารณะ: int โหลด (int x) {// แรกโหลด () ฟังก์ชั่น a = x; กลับมา; } int load (int x, int y) {// วินาทีโหลด () ฟังก์ชั่น a = x; ข y =; คืน a * b; }}; int main () {โอเวอร์โหลด O1; O1.load (20); // first load () เรียกใช้ฟังก์ชัน O1.load (20, 40); // การโหลดครั้งที่สอง () การเรียกใช้ฟังก์ชัน} 

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

ความหมายของการเอาชนะ

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

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

การใช้งานของการเอาชนะใน C ++

 ชั้นฐาน {สาธารณะ: ฟังก์ชั่นโมฆะเสมือน () {// ฟังก์ชั่นเสมือนจริงของชั้นศาล << "นี่คือฟังก์ชั่นชั้นฐานของ" () "; }}; ระดับที่ได้รับ 1: ฐานสาธารณะ {สาธารณะ: เป็นโมฆะฟังก์ชั่น () {// ฟังก์ชั่นเสมือนจริงของระดับฐานที่กำหนดไว้ในชั้นเรียนที่ได้รับมา << "นี่คือฟังก์ชั่นคลาสที่ได้รับของ 1 ()"; }}; ระดับ class2: สาธารณะฐาน {สาธารณะ: เป็นโมฆะฟังก์ชั่น () {// ฟังก์ชั่นเสมือนจริงของชั้นฐานกำหนดไว้ในชั้นเรียนที่ได้รับ 2  funct (); // เรียกไปยังคลาสที่ได้รับ function1 () * p = & D2; p-> funct (); // เรียกไปยังฟังก์ชันที่ได้รับ class2 () กลับ 0 } 

ที่นี่มีคลาสฐานเดียวที่สืบทอดต่อสาธารณะโดยคลาสที่ได้รับสองคลาส ฟังก์ชั่นเสมือนถูกกำหนดไว้ในคลาสฐานที่มีคำหลัก 'เสมือน' และถูกกำหนดใหม่โดยทั้งคลาสที่ได้รับโดยไม่มีคำหลัก ใน main () คลาสพื้นฐานสร้างตัวแปรตัวชี้ 'p' และวัตถุ 'b' คลาส 'ที่ได้รับ 1' สร้างวัตถุ d1 และคลาสที่ได้รับมาสร้างวัตถุที่ d2 '

ตอนนี้เริ่มต้นที่อยู่ของวัตถุชั้นฐาน 'b' ถูกกำหนดให้ตัวชี้ของชั้นฐาน 'p' 'p' ให้การเรียกใช้ฟังก์ชัน function () ดังนั้นจึงเรียกใช้ฟังก์ชันของคลาสพื้นฐาน จากนั้นที่อยู่ของวัตถุคลาสที่ได้รับมา 'd1' ถูกกำหนดให้กับตัวชี้ 'p' อีกครั้งจะให้การเรียกฟังก์ชั่น (); นี่คือการใช้งานฟังก์ชั่น () ของคลาสที่ได้รับมา 1 ในที่สุดตัวชี้ 'p' ถูกกำหนดให้กับวัตถุของคลาสที่ได้รับ 2 จากนั้น 'p' จะเรียกใช้ฟังก์ชัน function () ซึ่งเรียกใช้งานฟังก์ชัน func () ของคลาสที่ได้รับ

ถ้า class1 ที่ได้รับ / ที่ได้รับไม่ได้กำหนดฟังก์ชัน () อีกครั้งฟังก์ชัน () ของคลาสพื้นฐานจะถูกเรียกใช้เนื่องจากฟังก์ชันเสมือนคือ 'ลำดับชั้น'

ความแตกต่างที่สำคัญระหว่างการบรรทุกเกินพิกัดและการเอาชนะ

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

ความคล้ายคลึงกัน

  1. ทั้งสองถูกนำไปใช้กับฟังก์ชั่นสมาชิกของชั้นเรียน
  2. ความแตกต่างเป็นแนวคิดพื้นฐานที่อยู่เบื้องหลังพวกเขาทั้งสอง
  3. ชื่อฟังก์ชั่นยังคงเหมือนเดิมในขณะที่เราใช้งานมากไปและแทนที่ไปยังฟังก์ชั่น

ข้อสรุป

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

Top