C ++ เป็นหนึ่งในภาษาการเขียนโปรแกรมที่มีความยืดหยุ่นสูงและยังครอบคลุมคุณสมบัติหลายประการของการเขียนโปรแกรมเชิงวัตถุ การโอเวอร์โหลดเป็นอีกคุณสมบัติหนึ่งของภาษาโปรแกรมนี้คำแนะนำต่อไปนี้จะกล่าวถึงในบทความ“ Function Overloading in C ++” -
- C ++ มากเกินไป
- ประเภทของการโอเวอร์โหลดใน C ++
- ฟังก์ชันโอเวอร์โหลดใน C ++ คืออะไร
- โดยการเปลี่ยนจำนวนอาร์กิวเมนต์
- โดยมีอาร์กิวเมนต์ประเภทต่างๆ
- ข้อดีของการทำงานมากเกินไปใน C ++
- ข้อเสียของการทำงานมากเกินไปใน C ++
- ฟังก์ชัน Overloading และ Ambiguity
C ++ มากเกินไป
เมื่อเราสร้างสมาชิกสองคนขึ้นไปของคลาสที่มีชื่อเดียวกัน แต่มีจำนวนหรือประเภทของพารามิเตอร์ต่างกันเรียกว่าการโอเวอร์โหลด C ++ ใน C ++ เราสามารถโอเวอร์โหลด:
การมีเพศสัมพันธ์แบบหลวมใน java คืออะไร
- วิธีการ
- ผู้สร้างและ
- คุณสมบัติที่จัดทำดัชนี
ประเภทของการโอเวอร์โหลดใน C ++
ฟังก์ชันโอเวอร์โหลดใน C ++ คืออะไร?
ฟังก์ชันโอเวอร์โหลดใน C ++ สามารถกำหนดได้ว่าเป็นกระบวนการของการมีฟังก์ชันสมาชิกสองฟังก์ชันขึ้นไปของคลาสที่มีชื่อเดียวกัน แต่แตกต่างกันในพารามิเตอร์ ในการโอเวอร์โหลดฟังก์ชันฟังก์ชันสามารถกำหนดใหม่ได้โดยใช้อาร์กิวเมนต์ประเภทต่างๆหรืออาร์กิวเมนต์ที่แตกต่างกันตามข้อกำหนด มันเป็นเพียงคอมไพเลอร์ความแตกต่างเหล่านี้เท่านั้นที่สามารถแยกความแตกต่างระหว่างสองฟังก์ชันที่โอเวอร์โหลด
ข้อได้เปรียบที่สำคัญอย่างหนึ่งของ Function overloading คือการเพิ่มความสามารถในการอ่านของโปรแกรมเนื่องจากเราไม่จำเป็นต้องใช้ชื่อที่แตกต่างกันสำหรับการทำงานเดียวกันซ้ำแล้วซ้ำเล่า
โดยการเปลี่ยนจำนวนอาร์กิวเมนต์
ในการโอเวอร์โหลดฟังก์ชันนี้เรากำหนดสองฟังก์ชันที่มีชื่อเหมือนกัน แต่มีพารามิเตอร์ประเภทเดียวกันจำนวนต่างกัน ตัวอย่างเช่นในโปรแกรมที่กล่าวถึงด้านล่างเราได้สร้างฟังก์ชัน add () สองฟังก์ชันเพื่อส่งกลับผลรวมของจำนวนเต็มสองและสาม
// คำจำกัดความฟังก์ชันแรก int add (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }
ฟังก์ชั่น add () ที่นี่ถูกกล่าวว่าโอเวอร์โหลดเนื่องจากมีคำจำกัดความสองคำหนึ่งซึ่งยอมรับสองอาร์กิวเมนต์และอีกอันที่ยอมรับสามอาร์กิวเมนต์ ฟังก์ชัน add () ใดจะถูกเรียกขึ้นอยู่กับจำนวนอาร์กิวเมนต์
int main () {add (10, 20) // add () พร้อม 2 พารามิเตอร์จะถูกเรียกว่า add (10, 20, 30) // sum () โดยจะเรียกพารามิเตอร์ 3 ตัว}
#include โดยใช้ namespace std int add (int a, int b) {cout<< a+b <ในตัวอย่างข้างต้นเราโอเวอร์โหลดฟังก์ชัน add () โดยการเปลี่ยนจำนวนอาร์กิวเมนต์ ขั้นแรกเรากำหนดฟังก์ชัน add () ด้วยพารามิเตอร์สองตัวจากนั้นเราโอเวอร์โหลดโดยกำหนดฟังก์ชัน add () อีกครั้ง แต่คราวนี้มีพารามิเตอร์สามตัว
โดยมีอาร์กิวเมนต์ประเภทต่างๆ
ในวิธีนี้เรากำหนดฟังก์ชันตั้งแต่สองฟังก์ชันขึ้นไปด้วยชื่อเดียวกันและจำนวนพารามิเตอร์เดียวกัน แต่ประเภทข้อมูลที่ใช้สำหรับพารามิเตอร์เหล่านี้แตกต่างกัน ตัวอย่างเช่นในโปรแกรมนี้เรามีฟังก์ชัน add () สามตัวอันแรกได้รับอาร์กิวเมนต์จำนวนเต็มสองอาร์กิวเมนต์ตัวที่สองได้รับอาร์กิวเมนต์ลอยสองอาร์กิวเมนต์และอันที่สามได้รับอาร์กิวเมนต์สองคู่
#include โดยใช้ namespace std int add (int x, int y) // นิยามแรก {cout<< x+y << endl return 0 } float add(float a, float b) { cout << a+b << endl return 0 } double add(double x, double y) { cout << x+y << endl return 0 } int main() { add(20, 40) add(23.45f, 34.5f) add(40.24, 20.433) }ในตัวอย่างข้างต้นเรากำหนดฟังก์ชัน add () สามครั้ง อันดับแรกใช้จำนวนเต็มเป็นพารามิเตอร์อันดับสองใช้ float เป็นพารามิเตอร์และอันดับสามใช้ double เป็นพารามิเตอร์
ดังนั้นเราจึงแทนที่ฟังก์ชัน add () สองครั้งข้อดีของฟังก์ชัน Overloading ใน C ++
เราใช้ฟังก์ชันโอเวอร์โหลดเพื่อประหยัดพื้นที่หน่วยความจำความสม่ำเสมอและความสามารถในการอ่านโปรแกรมของเรา
ด้วยแนวคิดการใช้ฟังก์ชันมากเกินไปเราสามารถพัฒนาฟังก์ชันที่มีชื่อเดียวกันได้มากกว่าหนึ่งฟังก์ชัน
การโอเวอร์โหลดของฟังก์ชันแสดงพฤติกรรมของความหลากหลายที่ทำให้เราได้รับพฤติกรรมที่แตกต่างกันแม้ว่าจะมีลิงก์บางส่วนที่ใช้ชื่อเดียวกันของฟังก์ชัน
ฟังก์ชั่นที่มากเกินไปทำให้การทำงานของโปรแกรมเร็วขึ้น
การโอเวอร์โหลดฟังก์ชันใช้สำหรับการใช้โค้ดซ้ำและเพื่อประหยัดหน่วยความจำ
ช่วยให้แอปพลิเคชันโหลดเมธอดคลาสตามประเภทของพารามิเตอร์
การบำรุงรักษาโค้ดทำได้ง่าย
ข้อเสียของฟังก์ชันโอเวอร์โหลดใน C ++
- การประกาศฟังก์ชันที่แตกต่างกันตามประเภทการส่งคืนเท่านั้นไม่สามารถโอเวอร์โหลดได้ด้วยกระบวนการโอเวอร์โหลดฟังก์ชัน
- การประกาศฟังก์ชันสมาชิกที่มีพารามิเตอร์เดียวกันหรือประเภทชื่อเดียวกันไม่สามารถโอเวอร์โหลดได้หากมีการประกาศฟังก์ชันสมาชิกแบบคงที่
คลาส XYZ {static void func () void func () // error}ฟังก์ชัน Overloading และ Ambiguity
เมื่อคอมไพลเลอร์ไม่สามารถตัดสินใจได้ว่าควรเรียกใช้ฟังก์ชันใดก่อนในหมู่ฟังก์ชันที่โอเวอร์โหลดสถานการณ์นี้เรียกว่าฟังก์ชันโอเวอร์โหลดความคลุมเครือ คอมไพลเลอร์ไม่รันโปรแกรมหากแสดงข้อผิดพลาดความไม่ชัดเจน สาเหตุของฟังก์ชั่นความคลุมเครือมากเกินไป:
- ประเภทการแปลง
- ฟังก์ชันที่มีอาร์กิวเมนต์เริ่มต้น
- ฟังก์ชันที่มีการอ้างอิงผ่าน
ประเภทการแปลง:
#include โดยใช้ namespace std void function (float) void function (int) void function (float x) {std :: cout<< 'Value of x is : ' <ตัวอย่างด้านบนแสดงข้อผิดพลาด - 'การเรียกใช้' function (double) 'มากเกินไปไม่ชัดเจน' ฟังก์ชัน (3.4) จะเรียกใช้ฟังก์ชันแรก ฟังก์ชัน (34) เรียกฟังก์ชันที่สองตามการคาดคะเนของเรา แต่นี่ไม่ใช่สิ่งที่เกิดขึ้นเนื่องจากใน C ++ ค่าคงที่จุดลอยตัวทั้งหมดจะถือว่าเป็นสองเท่าไม่ใช่ลอย หากเราแทนที่ตัวแปร float เป็นตัวแปรคู่โปรแกรมจะทำงานได้ดี ดังนั้นเราจึงเรียกสิ่งนี้ว่าข้อผิดพลาดในการแปลงประเภทจาก float เป็น double
ฟังก์ชันที่มีอาร์กิวเมนต์เริ่มต้น:
# รวมการใช้ namespace std void function (int) void function (int, int) void function (int x) {std :: cout<< 'Value of x is : ' <ตัวอย่างข้างต้นให้ข้อผิดพลาดว่า“ การเรียกใช้งานมากเกินไป ‘fun (int)’ คลุมเครือ” เนื่องจากฟังก์ชัน (int y, int z = 12) สามารถเรียกได้สองวิธี:
- โดยเรียกใช้ฟังก์ชันด้วยอาร์กิวเมนต์เดียว (และจะใช้ค่า z = 12 โดยอัตโนมัติ)
- โดยการเรียกใช้ฟังก์ชันด้วยสองอาร์กิวเมนต์
เมื่อเราเรียกใช้ฟังก์ชัน: ฟังก์ชัน (12) เราเติมเต็มเงื่อนไขของทั้งฟังก์ชัน (int) และฟังก์ชัน (int, int) ดังนั้นคอมไพเลอร์ที่เข้าสู่ความไม่ชัดเจนจะแสดงข้อผิดพลาด
ฟังก์ชั่นผ่านการอ้างอิง
#include โดยใช้ namespace std void function (int) void function (int &) void function (int a) {std :: cout<< 'Value of a is : ' <โปรแกรมข้างต้นให้ข้อผิดพลาดว่า 'การเรียกร้องให้มีการโอเวอร์โหลด' สนุก (int &) 'คลุมเครือ' ดังที่เราเห็นว่าฟังก์ชันแรกใช้อาร์กิวเมนต์จำนวนเต็มหนึ่งอาร์กิวเมนต์และฟังก์ชันที่สองรับพารามิเตอร์อ้างอิงเป็นอาร์กิวเมนต์ ในกรณีนี้คอมไพลเลอร์ไม่สามารถเข้าใจว่าฟังก์ชันใดที่ผู้ใช้ต้องการเนื่องจากไม่มีความแตกต่างทางไวยากรณ์ระหว่าง fun (int) และ fun (int &) จึงทำให้เกิดข้อผิดพลาดของความคลุมเครือ
ด้วยเหตุนี้เราจึงมาถึงจุดสิ้นสุดของ Function Overloading ใน C ++ หากคุณต้องการเรียนรู้เพิ่มเติมโปรดดูไฟล์ โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ หลักสูตรการฝึกอบรมและการรับรอง Java J2EE และ SOA ของ Edureka ได้รับการออกแบบมาเพื่อฝึกอบรมคุณสำหรับแนวคิด Java ทั้งหลักและขั้นสูงพร้อมกับกรอบงาน Java ต่างๆเช่น Hibernate & Spring
มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของบล็อกนี้และเราจะติดต่อกลับโดยเร็วที่สุด