เนื้อหา

• 
  ตารางเปรียบเทียบ:
• คำจำกัดความของการบรรทุกเกินพิกัด
• การติดตั้งเกินพิกัดใน C ++
• ความหมายของการเอาชนะ
• การใช้งานของการเอาชนะใน C ++
• ความคล้ายคลึงกัน
• ข้อสรุป

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

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

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

1. แผนภูมิเปรียบเทียบ
2. คำนิยาม
3. ความแตกต่างที่สำคัญ
4. ความคล้ายคลึงกัน
5. ข้อสรุป

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

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

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

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

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

การติดตั้งเกินพิกัดใน C ++

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

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

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

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

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

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

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

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

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

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

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

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

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

ข้อสรุป

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