นอกจากนี้เราศึกษาความแตกต่างระหว่างการบรรทุกเกินพิกัดและการเอาชนะด้วยความช่วยเหลือของกราฟเปรียบเทียบ
ตารางเปรียบเทียบ:
| พื้นฐานสำหรับการเปรียบเทียบ | การบรรทุกเกินพิกัด | ที่เอาชนะ |
|---|---|---|
| แบบเดิม | ต้นแบบแตกต่างกันตามจำนวนหรือประเภทของพารามิเตอร์ที่อาจแตกต่างกัน | ทุกด้านของต้นแบบต้องเหมือนกัน |
| คำหลัก | ไม่มีการใช้คำค้นหาระหว่างการบรรทุกเกินพิกัด | ฟังก์ชั่นที่จะถูกแทนที่จะนำหน้าด้วยคำหลัก 'เสมือน' ในชั้นฐาน |
| ปัจจัยเด่น | หมายเลขหรือชนิดของพารามิเตอร์แตกต่างกันซึ่งกำหนดรุ่นของฟังก์ชันที่ถูกเรียก | ฟังก์ชันของคลาสใดที่ถูกเรียกใช้โดยตัวชี้ถูกกำหนดโดยที่อยู่ของวัตถุของคลาสที่ถูกกำหนดให้กับตัวชี้นั้น |
| การกำหนดรูปแบบ | ฟังก์ชันถูกนิยามใหม่ด้วยชื่อเดียวกัน แต่จำนวนและชนิดของพารามิเตอร์ต่างกัน | มีการกำหนดฟังก์ชั่นนำหน้าด้วยคำหลัก 'เสมือนจริง' ในคลาสหลักและกำหนดใหม่โดยคลาสที่ได้รับโดยไม่มีคำหลัก |
| เวลาแห่งความสำเร็จ | รวบรวมเวลา | ใช้เวลา |
| ตัวสร้าง / ฟังก์ชันเสมือน | ตัวสร้างสามารถโอเวอร์โหลดได้ | สามารถแทนที่ฟังก์ชันเสมือนได้ |
| 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 ที่ได้รับ / ที่ได้รับไม่ได้กำหนดฟังก์ชัน () อีกครั้งฟังก์ชัน () ของคลาสพื้นฐานจะถูกเรียกใช้เนื่องจากฟังก์ชันเสมือนคือ 'ลำดับชั้น'
ความแตกต่างที่สำคัญระหว่างการบรรทุกเกินพิกัดและการเอาชนะ
- ต้นแบบของฟังก์ชันที่มีการโหลดมากเกินไปแตกต่างกันเนื่องจากชนิดและจำนวนของพารามิเตอร์ที่ถูกส่งผ่านไปยังฟังก์ชันที่โอเวอร์โหลด ในทางกลับกันต้นแบบของฟังก์ชั่นแทนที่จะไม่เปลี่ยนเพราะฟังก์ชั่นแทนที่ดำเนินการที่แตกต่างกันสำหรับระดับที่แตกต่างกันมันเป็นของ แต่มีประเภทและจำนวนของพารามิเตอร์เดียวกัน
- ชื่อฟังก์ชั่นโอเวอร์โหลดไม่ได้นำหน้าด้วยคำหลักใด ๆ ในขณะที่ชื่อของฟังก์ชั่นการแทนที่ที่นำหน้าด้วยคีย์การ์ด "เสมือน" ในชั้นฐานเท่านั้น
- ฟังก์ชันที่โอเวอร์โหลดนั้นถูกเรียกใช้ขึ้นอยู่กับชนิดหรือจำนวนของพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชัน ฟังก์ชั่นแทนที่ของชั้นเรียนที่ถูกเรียกขึ้นอยู่กับที่อยู่วัตถุของชั้นเรียนที่ได้รับมอบหมายให้ตัวชี้ซึ่งเรียกฟังก์ชั่น
- ฟังก์ชันที่โอเวอร์โหลดใดที่จะถูกเรียกใช้จะถูกแก้ไขในช่วงเวลารวบรวม ฟังก์ชันที่ถูกแทนที่ใดที่จะเรียกใช้ถูกแก้ไขระหว่างรันไทม์
- ตัวสร้างสามารถโอเวอร์โหลดได้ แต่ไม่สามารถแทนที่ได้
- Destructors ไม่สามารถโหลดได้มากเกินไป แต่สามารถลบล้างได้
- การโหลดมากเกินไปจะได้รับการผูก แต่เนิ่น ๆ ซึ่งฟังก์ชันที่โอเวอร์โหลดจะถูกเรียกใช้จะถูกแก้ไขในช่วงเวลารวบรวม การเอาชนะการใช้การรวมล่าช้าเนื่องจากฟังก์ชันที่แทนที่จะถูกเรียกใช้จะถูกแก้ไขในระหว่างการรันไทม์
ความคล้ายคลึงกัน
- ทั้งสองถูกนำไปใช้กับฟังก์ชั่นสมาชิกของชั้นเรียน
- ความแตกต่างเป็นแนวคิดพื้นฐานที่อยู่เบื้องหลังพวกเขาทั้งสอง
- ชื่อฟังก์ชั่นยังคงเหมือนเดิมในขณะที่เราใช้งานมากไปและแทนที่ไปยังฟังก์ชั่น
ข้อสรุป
การบรรทุกเกินพิกัดและการแทนที่จะปรากฏขึ้นคล้ายกัน แต่นี่ไม่ใช่กรณี ฟังก์ชันสามารถโอเวอร์โหลดได้ แต่คลาสใด ๆ ไม่สามารถกำหนดฟังก์ชันโอเวอร์โหลดได้ในอนาคต ฟังก์ชันเสมือนไม่สามารถโอเวอร์โหลดได้ พวกเขาสามารถถูกแทนที่เท่านั้น
