ทำไมหลายภาษาจึงผ่านค่า?

แม้แต่ภาษาที่คุณมีการจัดการตัวชี้อย่างชัดเจนเช่น C มันจะถูกส่งผ่านตามค่าเสมอ (คุณสามารถส่งต่อโดยการอ้างอิง แต่นั่นไม่ใช่พฤติกรรมเริ่มต้น)

ประโยชน์ของสิ่งนี้คืออะไรทำไมมีหลายภาษาที่ผ่านค่านิยมและทำไมคนอื่นถึงผ่านอ้างอิง ? (ฉันเข้าใจว่า Haskell ผ่านการอ้างอิงถึงแม้ว่าฉันไม่แน่ใจ)

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

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

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

Call-by-value และ call-by-reference เป็นเทคนิคการใช้งานที่ผิดพลาดสำหรับโหมดผ่านพารามิเตอร์เมื่อนานมาแล้ว

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

ALGOL เกิดขึ้นกับ call-by-name และ call-by-value Call-by-value ใช้สำหรับสิ่งที่ไม่ควรเปลี่ยน (พารามิเตอร์อินพุต) การโทรตามชื่อใช้สำหรับพารามิเตอร์เอาต์พุต การโทรตามชื่อกลายเป็นเรื่องสำคัญมากและ ALGOL 68 ก็ทำเช่นนั้น

PASCAL จัดเตรียมการเรียกใช้โดยค่าและการอ้างอิงโดยการเรียก มันไม่มีวิธีการใด ๆ ที่โปรแกรมเมอร์จะบอกคอมไพเลอร์ว่าเขาผ่านวัตถุขนาดใหญ่ (โดยปกติคืออาร์เรย์) โดยการอ้างอิงเพื่อหลีกเลี่ยงการเป่าพารามิเตอร์สแต็ก แต่ไม่ควรเปลี่ยนวัตถุ

PASCAL เพิ่มตัวชี้ไปยังพจนานุกรมการออกแบบภาษา

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

ภาษาต่อมาคัดลอก C ส่วนใหญ่เป็นเพราะนักออกแบบไม่เคยเห็นอะไรเลย นี่อาจเป็นสาเหตุที่ค่าโทรโดยค่านิยมมาก

C ++ เพิ่ม kludge ที่ด้านบนของ C kludge เพื่อให้การโทรโดยอ้างอิง

ตอนนี้เป็นผลโดยตรงของการโทรโดยค่าเทียบกับการโทรโดยการอ้างอิงกับการโทรโดยตัวชี้ kludge, C และ C ++ (โปรแกรมเมอร์) มีอาการปวดหัวที่น่ากลัวกับตัวชี้ const และตัวชี้ไปยัง const (อ่านอย่างเดียว) วัตถุ

Ada พยายามหลีกเลี่ยงฝันร้ายทั้งหมดนี้

Ada ไม่มี call-by-value และ call-by-reference อย่างชัดเจน ค่อนข้าง Ada มีพารามิเตอร์ (ซึ่งอาจจะอ่าน แต่ไม่ได้เขียน), พารามิเตอร์ out (ซึ่งจะต้องเขียนก่อนที่จะสามารถอ่านได้) และพารามิเตอร์ out ซึ่งอาจอ่านและเขียนในลำดับใดก็ได้ คอมไพเลอร์ตัดสินใจว่าพารามิเตอร์เฉพาะถูกส่งผ่านโดยค่าหรือโดยการอ้างอิง: มันโปร่งใสให้โปรแกรมเมอร์

การผ่านการอ้างอิงช่วยให้มีผลข้างเคียงที่ไม่ได้ตั้งใจอย่างละเอียดซึ่งยากมากที่จะติดกับสิ่งที่เป็นไปไม่ได้ที่จะติดตามเมื่อพวกเขาเริ่มก่อให้เกิดพฤติกรรมที่ไม่ได้ตั้งใจ

ผ่านค่าโดยเฉพาะอย่างยิ่งfinal, staticหรือconstป้อนพารามิเตอร์นี้จะทำให้ทั้งชั้นของโรคจิตหายไป

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

ทำไมหลายภาษาจึงผ่านค่า?

จุดของการแบ่งโปรแกรมขนาดใหญ่ออกเป็นรูทีนย่อยขนาดเล็กคือคุณสามารถให้เหตุผลเกี่ยวกับรูทีนย่อยได้อย่างอิสระ Pass-by-Reference แบ่งคุณสมบัตินี้ (เช่นเดียวกับสถานะที่ไม่แน่นอนที่แชร์กัน)

แม้แต่ภาษาที่คุณมีการจัดการตัวชี้อย่างชัดเจนเช่น C มันจะถูกส่งผ่านตามค่าเสมอ (คุณสามารถส่งต่อโดยการอ้างอิง แต่นั่นไม่ใช่พฤติกรรมเริ่มต้น)

ที่จริงแล้ว C อยู่เสมอโดยผ่านค่าไม่เคยผ่านการอ้างอิง คุณสามารถใช้ที่อยู่ของบางสิ่งบางอย่างและส่งผ่านที่อยู่นั้นได้ แต่ที่อยู่จะยังคงถูกส่งผ่านตามค่า

ประโยชน์ของสิ่งนี้คืออะไรทำไมมีหลายภาษาที่ผ่านค่านิยมและทำไมคนอื่นถึงผ่านอ้างอิง ?

มีสองเหตุผลหลักในการใช้การอ้างอิงแบบอ้างอิงถึง:

1. จำลองค่าส่งคืนหลายค่า
2. อย่างมีประสิทธิภาพ

โดยส่วนตัวฉันคิดว่า # 1 เป็นของปลอม: มันเกือบจะเป็นข้อแก้ตัวสำหรับ API ที่ไม่ดีและ / หรือการออกแบบภาษา:

1. หากคุณต้องการค่าส่งคืนหลายค่าอย่าจำลองพวกเขาเพียงแค่ใช้ภาษาที่รองรับพวกเขา

2. คุณสามารถจำลองค่าที่ส่งคืนได้หลายค่าด้วยการบรรจุลงในโครงสร้างข้อมูลที่มีน้ำหนักเบาเช่น tuple วิธีนี้ใช้ได้ผลดีหากภาษารองรับการจับคู่รูปแบบหรือการผูกมัดแบบทำลาย เช่นทับทิม

   def foo
     # This is actually just a single return value, an array: [1, 2, 3]
     return 1, 2, 3
   end
   
   # Ruby supports destructuring bind for arrays: a, b, c = [1, 2, 3]
   one, two, three = foo
   

3. บ่อยครั้งคุณไม่จำเป็นต้องมีค่าส่งคืนหลายค่า ตัวอย่างเช่นรูปแบบหนึ่งที่เป็นที่นิยมคือรูทีนย่อยส่งคืนรหัสข้อผิดพลาดและผลลัพธ์จริงถูกเขียนกลับโดยการอ้างอิง คุณควรส่งข้อยกเว้นหากเกิดข้อผิดพลาดที่ไม่คาดคิดหรือส่งคืนEither<Exception, T>ถ้าคาดว่าจะเกิดข้อผิดพลาด อีกรูปแบบหนึ่งคือการส่งคืนบูลีนซึ่งบอกว่าการดำเนินการประสบความสำเร็จและส่งกลับผลลัพธ์ที่แท้จริงโดยการอ้างอิง อีกครั้งหากความล้มเหลวไม่คาดคิดคุณควรโยนข้อยกเว้นแทนหากคาดว่าจะเกิดความล้มเหลวเช่นเมื่อค้นหาค่าในพจนานุกรมคุณควรส่งคืนMaybe<T>แทน

Pass-by-Reference อาจมีประสิทธิภาพมากกว่า Pass-by-value เนื่องจากคุณไม่จำเป็นต้องคัดลอกค่า

(ฉันเข้าใจว่า Haskell ผ่านการอ้างอิงถึงแม้ว่าฉันไม่แน่ใจ)

ไม่ Haskell ไม่ได้ผ่านการอ้างอิง และมันก็ไม่คุ้มค่า Pass-by-Reference และ Pass-by-value เป็นทั้งกลยุทธ์การประเมินที่เข้มงวด แต่ Haskell นั้นไม่เข้มงวด

ในความเป็นจริงข้อกำหนด Haskell ไม่ได้ระบุกลยุทธ์การประเมินเฉพาะใด ๆ การใช้งานของ Hakell ส่วนใหญ่ใช้การโทรตามชื่อและการโทรตามความต้องการ (ตัวแปรของการโทรด้วยชื่อพร้อมบันทึก) แต่มาตรฐานไม่ได้บังคับสิ่งนี้

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

มีพฤติกรรมที่แตกต่างกันขึ้นอยู่กับรุ่นการโทรของภาษาประเภทของการขัดแย้งและรุ่นหน่วยความจำของภาษา

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

ในภาษา OO จำนวนมาก (C ++ เป็นข้อยกเว้นเพิ่มเติมในบริบทนี้) คุณไม่สามารถส่งผ่านวัตถุตามค่า คุณกำลังจะผ่านมันโดยการอ้างอิง สิ่งนี้ทำให้โค้ด polymorphic เป็นค่าเริ่มต้นและสอดคล้องกับแนวคิดของอินสแตนซ์ที่เหมาะสมกับ OO มากขึ้น นอกจากนี้หากคุณต้องการผ่านค่าคุณต้องทำสำเนาด้วยตัวคุณเองยอมรับต้นทุนของประสิทธิภาพที่สร้างการกระทำดังกล่าว ในกรณีนี้ภาษาเลือกวิธีที่มีแนวโน้มจะให้ประสิทธิภาพที่ดีที่สุดแก่คุณ

ในกรณีของภาษาที่ใช้งานได้ฉันคิดว่าการส่งผ่านค่าหรือการอ้างอิงเป็นเพียงคำถามของการปรับให้เหมาะสม เนื่องจากฟังก์ชั่นในภาษานั้นบริสุทธิ์และปราศจากผลข้างเคียงจึงไม่มีเหตุผลที่จะคัดลอกค่ายกเว้นความเร็ว ฉันค่อนข้างมั่นใจว่าภาษาดังกล่าวมักจะแบ่งปันสำเนาของวัตถุเดียวกันด้วยค่าเดียวกันความเป็นไปได้จะใช้ได้เฉพาะเมื่อคุณใช้ semantic อ้างอิงความหมายผ่าน Python ใช้เคล็ดลับนี้สำหรับสตริงจำนวนเต็มและสามัญ (เช่นเมธอดและชื่อคลาส) อธิบายว่าทำไมจำนวนเต็มและสตริงจึงเป็นวัตถุคงที่ใน Python สิ่งนี้ยังช่วยในการปรับรหัสให้เหมาะสมอีกครั้งโดยอนุญาตให้มีตัวชี้ตัวอย่าง comparaison แทน comparaison ของเนื้อหาและทำการประเมินข้อมูลภายในบางอย่างที่ขี้เกียจ

คุณสามารถผ่านการแสดงออกโดยค่ามันเป็นธรรมชาติ การส่งผ่านนิพจน์โดยการอ้างอิง (ชั่วคราว) คือ ... แปลก

หากคุณผ่านการอ้างอิงแสดงว่าคุณทำงานอย่างมีประสิทธิภาพกับค่านิยมทั่วโลกพร้อมกับปัญหาทั้งหมดของ globals (เช่นขอบเขตและผลข้างเคียงที่ไม่ได้ตั้งใจ)

บางครั้งการอ้างอิงก็มีประโยชน์เช่นกัน แต่มันไม่ควรเป็นตัวเลือกแรกของคุณ