เนื้อหา

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

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

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

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

แผนภูมิเปรียบเทียบ:

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

คำจำกัดความของการผูกแบบคงที่

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

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

การโอเวอร์โหลดฟังก์ชั่นหรือโอเปอเรเตอร์เป็นตัวอย่างของ polymorphism เวลาคอมไพล์เช่นการผูกแบบคงที่

การใช้งานการรวมแบบคงที่ใน C ++ พร้อมตัวอย่างของการโอเวอร์โหลด

#include ใช้ namespace std; คลาสเกินพิกัด {int a, b; public: int load (int x) ฟังก์ชั่น {// first load () A = x; ศาล << "ค่าของ x คือ" <funct (); // คำสั่งด้านบนตัดสินใจว่าจะเรียกใช้ฟังก์ชันคลาสใด p = & d1; // Vlaue ของตัวชี้เปลี่ยนแปลง p-> funct (); // คำสั่งด้านบนตัดสินใจว่าจะเรียกใช้ฟังก์ชันคลาสใด p = & D2; // อีกครั้ง vlaue ของตัวชี้เปลี่ยนแปลง p-> funct (); // คำสั่งด้านบนตัดสินใจว่าจะเรียกใช้ฟังก์ชันคลาสใด กลับ 0 }

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

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

สรุป:

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