1: ผ่านการโต้แย้งตามค่า
สำเนาของตัวแปรถูกสร้างและจัดเตรียมให้กับฟังก์ชันเมื่อ อาร์กิวเมนต์จะถูกส่งผ่านตามค่า . การแก้ไขทั้งหมดที่ทำกับตัวแปรภายในฟังก์ชันจะส่งผลต่อการคัดลอกเท่านั้น ไม่มีอะไรเปลี่ยนแปลงเป็นตัวแปรเดิม ผลที่ตามมา, ผ่านไปค่า เป็นวิธีการที่ปลอดภัยเนื่องจากไม่มีความเป็นไปได้ที่จะแก้ไขค่าของตัวแปรดั้งเดิมโดยไม่ได้ตั้งใจ
ผ่านค่า อย่างไรก็ตาม อาจไม่ได้ผล โดยเฉพาะอย่างยิ่งเมื่อต้องจัดการกับประเภทข้อมูลขนาดใหญ่หรือซับซ้อน การเรียกใช้ฟังก์ชันทุกครั้งที่ต้องการสำเนาข้อมูลจะทำให้ทรัพยากร CPU และหน่วยความจำหมดลงอย่างรวดเร็ว นอกจากนี้, ผ่านไปค่า ไม่สามารถใช้กับฟังก์ชันที่ต้องการเปลี่ยนค่าของตัวแปรต้นฉบับได้ เนื่องจากสำเนาและตัวแปรต้นฉบับไม่ได้เชื่อมโยงกัน
2: การโต้แย้งผ่านการอ้างอิง
ตัวแปรสามารถเป็นได้ ผ่านการอ้างอิง ใน C++ ด้วย ซึ่งช่วยแก้ปัญหาเหล่านี้ได้ ตัวแปรเดิมถูกส่งไปยังฟังก์ชันเมื่อ ผ่านการอ้างอิง และการแก้ไขใด ๆ ที่ดำเนินการกับตัวแปรภายในฟังก์ชันจะส่งผลต่อตัวแปรดั้งเดิมด้วย ด้วยเหตุนี้ ผ่านการอ้างอิง มีประสิทธิภาพมากกว่าอย่างมากสำหรับประเภทข้อมูลขนาดใหญ่หรือซับซ้อน และหลีกเลี่ยงความจำเป็นในการคัดลอก
เพื่อป้องกันการแก้ไขโดยไม่ได้ตั้งใจ ฟังก์ชันต้องถูกกำหนดอย่างชัดเจนเป็น const การเพิ่มคำหลัก const ในการประกาศฟังก์ชัน เช่นใน 'int คำนวณ(const int& a, const int& b)' จะทำให้สิ่งนี้สำเร็จ
อย่างไรก็ตาม, ผ่านการโต้แย้งโดยการอ้างอิง ต้องใส่ใจในรายละเอียดอย่างรอบคอบเช่นกัน โปรแกรมเมอร์ที่ไม่มีประสบการณ์สามารถทำผิดพลาดได้ เช่น การสร้างผลข้างเคียงโดยไม่ได้ตั้งใจ การแชร์ข้อมูลโดยไม่ได้ตั้งใจ และการลบล้างข้อมูลภายนอก
พิจารณารหัสต่อไปนี้ที่แสดงให้เห็นทั้งสองอย่าง วิธีการส่งผ่านอาร์กิวเมนต์ :
#รวมถึงใช้เนมสเปซมาตรฐาน ;
เป็นโมฆะ PassByValue ( นานาชาติ x ) {
x = 5 ;
ศาล << 'ภายใน PassByValue: ' << x << จบ ;
}
เป็นโมฆะ PassByReference ( นานาชาติ & x ) {
x = 5 ;
ศาล << 'ภายใน PassByReference: ' << x << จบ ;
}
นานาชาติ หลัก ( ) {
นานาชาติ หมายเลข 1 = 2 , หมายเลข 2 = 2 ;
ศาล << 'ก่อนเรียกใช้ฟังก์ชัน: num1=' << หมายเลข 1 << ' num2=' << หมายเลข 2 << จบ ;
PassByValue ( หมายเลข 1 ) ;
PassByReference ( หมายเลข 2 ) ;
ศาล << 'หลังจากการเรียกใช้ฟังก์ชัน: num1=' << หมายเลข 1 << ' num2=' << หมายเลข 2 << จบ ;
กลับ 0 ;
}
ในโค้ดข้างต้น ฟังก์ชันแรก PassByValue รับอาร์กิวเมนต์จำนวนเต็มตามค่า ภายในฟังก์ชัน ตัวแปรจำนวนเต็มใหม่จะถูกสร้างขึ้นและกำหนดค่าเป็น 5 จำนวนเต็มเดิมยังคงไม่ถูกแก้ไข ฟังก์ชันที่สอง PassByReference , รับอาร์กิวเมนต์จำนวนเต็มโดยการอ้างอิง ในกรณีนี้ ฟังก์ชันจะจัดการกับตัวแปรดั้งเดิมโดยตรง
เอาต์พุต
ตามที่คาดไว้ การเรียกครั้งแรกจะแสดงผล 5 แต่ไม่มีผลกับตัวแปรดั้งเดิม ในทางตรงกันข้าม การเรียกครั้งที่สองจะเปลี่ยนค่าของ num2 เป็น 5 ซึ่งส่งผลต่อผลลัพธ์ของคำสั่งสุดท้าย
ส่งผ่านมูลค่า เทียบกับ ส่งผ่านโดยการอ้างอิง
1: วิธีเรียกฟังก์ชัน
ความแตกต่างอย่างหนึ่งระหว่าง ผ่านไปค่า และ ผ่านการอ้างอิง เป็นวิธีเรียกใช้ฟังก์ชัน เมื่อไร ผ่านไปค่า การเรียกใช้ฟังก์ชันต้องใส่ค่าของตัวแปร เช่น `calculate(a, b)` เมื่อไร ผ่านการอ้างอิง การเรียกใช้ฟังก์ชันต้องมีที่อยู่หน่วยความจำของตัวแปร ซึ่งแสดงสัญลักษณ์ด้วยเครื่องหมายแอมเปอร์แซนด์ เช่น `คำนวณ(&a, &b)`
2: ประเภทข้อมูล
โดยทั่วไป ผ่านไปค่า เหมาะสมที่สุดเมื่อทำงานกับชนิดข้อมูลขนาดเล็กหรือธรรมดา หรือเมื่อฟังก์ชันไม่ได้มีวัตถุประสงค์เพื่อแก้ไขตัวแปรดั้งเดิม ผ่านการอ้างอิง จะเหมาะสมกว่าสำหรับประเภทข้อมูลขนาดใหญ่หรือซับซ้อน หรือเมื่อฟังก์ชันมีวัตถุประสงค์เพื่อแก้ไขค่าของตัวแปรดั้งเดิม
บทสรุป
เมื่อมีพารามิเตอร์ ผ่านไปค่า สำหรับฟังก์ชัน สำเนาของตัวแปรจะถูกสร้างและจัดหา โดย ผ่านการอ้างอิง ตัวแปรเดิมจะถูกส่งไปยังฟังก์ชัน ใน C ++ ส่งผ่านข้อโต้แย้งตามค่าหรือโดยการอ้างอิง เป็นแนวคิดพื้นฐาน การเลือกวิธีการที่เหมาะสมขึ้นอยู่กับสถานการณ์เฉพาะและควรได้รับการประเมินอย่างรอบคอบ ประโยชน์ของการใช้ อ้างอิง แนวทางสามารถส่งผลให้รหัสมีประสิทธิภาพมากขึ้นแม้จะมีสิ่งล่อใจให้ใช้ง่ายขึ้น ผ่านไปค่า วิธี.