วิธีการติดตั้ง Operator Overloading ใน c ++

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

• การโอเวอร์โหลดใน C ++
• ประเภทของการโอเวอร์โหลดใน C ++
• เหตุใดจึงใช้ตัวดำเนินการมากเกินไป
• การใช้ Operator Overloading ใน C ++
• ประเภทของวิธีการโอเวอร์โหลด
• โอเวอร์โหลด Unary Operators
• ตัวดำเนินการไบนารีมากเกินไป

ดังนั้นให้เราเริ่มต้นด้วยบทความนี้เกี่ยวกับ Operator Overloading ใน C ++

การโอเวอร์โหลดใน C ++

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

tostring หมายถึงอะไรใน java

ใน C ++ เราสามารถโอเวอร์โหลด:

• วิธีการ
• ช่างก่อสร้าง
• คุณสมบัติที่จัดทำดัชนี

เป็นเพราะสมาชิกเหล่านี้มีพารามิเตอร์เท่านั้น

ไปต่อกับบทความนี้เกี่ยวกับ Operator Overloading ใน C ++

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

• ฟังก์ชั่นมากเกินไป
• ตัวดำเนินการมากเกินไป

ไปต่อกับบทความนี้เกี่ยวกับ Operator Overloading ใน C ++

เหตุใดจึงใช้ตัวดำเนินการมากเกินไป

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

เราสามารถแทนที่รหัสเช่น:

การคำนวณ = เพิ่ม (หาร (a, b), คูณ (a, b))

สำหรับสมการ

การคำนวณ = (a / b) + (a * b)

การโอเวอร์โหลดตัวดำเนินการเป็นวิธีที่ง่ายและสะดวกสำหรับการพัฒนาคำจำกัดความใหม่สำหรับตัวดำเนินการส่วนใหญ่ใน C ++ ด้วยความรู้ที่เพียงพอเราแทบจะสามารถสร้างภาษาใหม่ของเราเองได้ด้วยการใช้ฟังก์ชันและเทคนิคการโอเวอร์โหลดตัวดำเนินการอย่างสร้างสรรค์ เราสามารถโอเวอร์โหลดตัวดำเนินการทั้งหมดใน C ++ ได้ยกเว้นสิ่งต่อไปนี้:
●ตัวดำเนินการขอบเขต (: :)
●ตัวดำเนินการขนาด (Sizeof)
●ตัวเลือกสมาชิก (.)
●ตัวเลือกตัวชี้สมาชิก (*)
●ตัวดำเนินการที่เกี่ยวข้อง (? :)

ไวยากรณ์ของ Operator Overloading

return_type class_name:: operator op (อาร์กิวเมนต์_list) {// function body}

โดยที่ประเภทการส่งคืนคือชนิดของค่าที่ส่งคืนโดยฟังก์ชัน class_name คือชื่อของคลาส

ไปต่อกับบทความนี้เกี่ยวกับ Operator Overloading ใน C ++

การใช้ Operator Overloading ใน C ++

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

ความแตกต่างระหว่างฟังก์ชันตัวดำเนินการและฟังก์ชันปกติคืออะไร?

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

ไปต่อกับบทความนี้เกี่ยวกับ Operator Overloading ใน C ++

ประเภทของวิธีการโอเวอร์โหลด

Operator Overloading สามารถทำได้โดยใช้สามวิธีคือ

• โอเวอร์โหลดตัวดำเนินการ unary
• ตัวดำเนินการไบนารีมากเกินไป
• การโอเวอร์โหลดตัวดำเนินการไบนารีโดยใช้ฟังก์ชันเพื่อน

ไปต่อกับบทความนี้เกี่ยวกับ Operator Overloading ใน C ++

โอเวอร์โหลด Unary Operator

ให้เราพิจารณาตัวดำเนินการ unary '-' ตัวดำเนินการลบเมื่อใช้เป็นยูนารีต้องใช้ตัวถูกดำเนินการเพียงตัวเดียว เราทราบดีว่าตัวดำเนินการนี้เปลี่ยนสัญลักษณ์ของตัวถูกดำเนินการเมื่อใช้กับตัวแปรข้อมูลพื้นฐาน ให้เราดูวิธีการโอเวอร์โหลดโอเปอเรเตอร์นี้เพื่อให้สามารถนำไปใช้กับอ็อบเจ็กต์ในลักษณะเดียวกับที่ใช้กับตัวแปร int หรือ float ยูนารีลบเมื่อใช้กับออบเจ็กต์ควรลดรายการข้อมูลแต่ละรายการ

ตัวอย่าง:

# รวมการใช้เนมสเปซคลาส std ความสูง {public: // Member Objects int feet, inch // Constructor เพื่อเริ่มต้นค่าของอ็อบเจ็กต์ Height (int f, int i) {feet = f inch = i} // Overloading (-) ตัวดำเนินการถึง ดำเนินการลด // การดำเนินการของตัวดำเนินการโมฆะวัตถุความสูง - () {ฟุต - นิ้ว - cout<< 'Feet & Inches after decrement: ' << feet << ' ' ' << inch <
 เอาท์พุต: 
 คำอธิบาย:  
ในตัวอย่างข้างต้นเราโอเวอร์โหลดโอเปอเรเตอร์ unary '-' มากเกินไปเพื่อทำการลดค่าในตัวแปรสองตัวของระดับความสูง เราส่งพารามิเตอร์สองตัวไปยังตัวสร้างและบันทึกค่าเป็นตัวแปรฟุตและนิ้ว จากนั้นเรากำหนดตัวดำเนินการฟังก์ชันโอเวอร์โหลด (โมฆะตัวดำเนินการ - () 
) ซึ่งตัวแปรทั้งสองจะลดลงหนึ่งตำแหน่ง 
เมื่อเราเขียน -h1 มันจะเรียกใช้ฟังก์ชันการโอเวอร์โหลดของตัวดำเนินการและลดค่าที่ส่งผ่านไปยังตัวสร้าง
ไปต่อกับบทความนี้เกี่ยวกับ Operator Overloading ใน C ++
 ตัวดำเนินการไบนารีมากเกินไป 
เป็นการทำงานเกินพิกัดของตัวดำเนินการที่ทำงานกับตัวถูกดำเนินการสองตัว เรามาดูตัวอย่างของคลาสความสูงกัน แต่คราวนี้เพิ่มออบเจ็กต์ความสูง h1 และ h2 สองรายการ
 ตัวอย่าง: 
#include ใช้เนมสเปซคลาส std ความสูง {public: int feet, inch Height () {feet = 0 inch = 0} Height (int f, int i) {feet = f inch = i} // Overloading (+) operator เพื่อดำเนินการ การเพิ่ม // สองวัตถุระยะทางโดยใช้ตัวดำเนินการไบนารีตัวดำเนินการความสูง + (ความสูง & d2) // เรียกตามการอ้างอิง {// สร้างวัตถุเพื่อส่งคืนความสูง h3 // เพิ่มฟุตและนิ้ว h3.feet = ฟุต + d2.feet h3 นิ้ว = นิ้ว + d2.inch // ส่งคืนวัตถุที่เป็นผลลัพธ์กลับ h3}} int main () {ความสูง h1 (3, 7) ความสูง h2 (6, 1) ความสูง h3 // ใช้ตัวดำเนินการที่โอเวอร์โหลด h3 = h1 + h2 cout<< 'Sum of Feet & Inches: ' << h3.feet << ''' << h3.inch << endl return 0 } 
 เอาท์พุต:  
 
 คำอธิบาย:  
ตัวดำเนินการความสูง + (ความสูง & h2) ที่นี่ return_type ของฟังก์ชันคือ class Height ดังนั้นจึงส่งคืนอ็อบเจ็กต์ h3 ของคลาส Height ในบรรทัด h3 = h1 + h2, h1 เรียกใช้ฟังก์ชันตัวดำเนินการของคลาสอ็อบเจ็กต์และรับ h2 เป็นพารามิเตอร์จากนั้นเราใช้ h3.feet = feet + d2.feet และ h3.inch = inch + d2.inch ซึ่งเก็บ ผลรวมของค่าของตัวแปรฟุตและนิ้วในตัวแปรที่เกี่ยวข้องกับวัตถุ h3 
เมื่อคำสั่ง 'h3 = h1 + h2' เรียกใช้ตัวดำเนินการฟังก์ชันที่โอเวอร์โหลดอ็อบเจ็กต์ h1 รับหน้าที่เรียกใช้ฟังก์ชันและ h2 เล่นบทบาทของอาร์กิวเมนต์ที่ส่งผ่านไปยังฟังก์ชัน คำสั่งเรียกใช้ข้างต้นเทียบเท่ากับ h3 = h1.operator + (h2) ดังนั้นสมาชิกข้อมูลของ h2 จึงถูกเข้าถึงโดยตรงและสมาชิกข้อมูลของ h2 (ที่ส่งผ่านเป็นอาร์กิวเมนต์) จะถูกเข้าถึงโดยใช้ตัวดำเนินการจุด
 กฎสำหรับ Operator Overloading 
เฉพาะตัวดำเนินการที่มีอยู่เท่านั้นที่สามารถโอเวอร์โหลดและตัวดำเนินการใหม่ไม่สามารถโอเวอร์โหลดได้
ตัวดำเนินการที่โอเวอร์โหลดต้องมีตัวถูกดำเนินการอย่างน้อยหนึ่งชนิดของข้อมูลที่ผู้ใช้กำหนดเอง
เราไม่ใช้ฟังก์ชันเพื่อนเพื่อโอเวอร์โหลดโอเปอเรเตอร์บางตัว อย่างไรก็ตามฟังก์ชันสมาชิกสามารถใช้เพื่อโอเวอร์โหลดตัวดำเนินการเหล่านั้นได้
เมื่อตัวดำเนินการ unary ทำงานมากเกินไปผ่านฟังก์ชันสมาชิกพวกเขาจะไม่มีอาร์กิวเมนต์ที่ชัดเจน แต่ถ้าฟังก์ชันเพื่อนมากเกินไปพวกเขาจะใช้อาร์กิวเมนต์เดียว
เมื่อตัวดำเนินการไบนารีทำงานมากเกินไปผ่านฟังก์ชันสมาชิกพวกเขาจะใช้อาร์กิวเมนต์ที่ชัดเจนหนึ่งอาร์กิวเมนต์และหากมีการทำงานมากเกินไปผ่านฟังก์ชันเพื่อนจะรับอาร์กิวเมนต์ที่ชัดเจนสองอาร์กิวเมนต์
ดังนั้นเราจึงมาถึงตอนท้ายของบทความนี้เรื่อง 'Operator Overloading in C ++' หากคุณต้องการเรียนรู้เพิ่มเติมโปรดดู Java Training โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ Edureka’s  หลักสูตรได้รับการออกแบบมาเพื่อฝึกฝนคุณสำหรับแนวคิด Java ทั้งหลักและขั้นสูงพร้อมกับกรอบงาน Java ต่างๆเช่น Hibernate & Spring
 มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของบล็อกนี้และเราจะติดต่อกลับโดยเร็วที่สุด