ฟังก์ชันโอเวอร์โหลดใน C ++: สิ่งที่คุณต้องรู้

บทความนี้จะให้ความรู้โดยละเอียดและครอบคลุมเกี่ยวกับ Function Overloading ใน C ++ พร้อมตัวอย่างมากมายให้คุณเข้าใจ

C ++ เป็นหนึ่งในภาษาการเขียนโปรแกรมที่มีความยืดหยุ่นสูงและยังครอบคลุมคุณสมบัติหลายประการของการเขียนโปรแกรมเชิงวัตถุ การโอเวอร์โหลดเป็นอีกคุณสมบัติหนึ่งของภาษาโปรแกรมนี้คำแนะนำต่อไปนี้จะกล่าวถึงในบทความ“ Function Overloading in C ++” -



C ++ มากเกินไป

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



การมีเพศสัมพันธ์แบบหลวมใน java คืออะไร
  • วิธีการ
  • ผู้สร้างและ
  • คุณสมบัติที่จัดทำดัชนี

ประเภทของการโอเวอร์โหลดใน C ++

types-of-overloading-in-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) สามารถเรียกได้สองวิธี:

  1. โดยเรียกใช้ฟังก์ชันด้วยอาร์กิวเมนต์เดียว (และจะใช้ค่า z = 12 โดยอัตโนมัติ)
  2. โดยการเรียกใช้ฟังก์ชันด้วยสองอาร์กิวเมนต์

เมื่อเราเรียกใช้ฟังก์ชัน: ฟังก์ชัน (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

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