การขาดเครื่องหมาย ampersand (&) เพียงตัวเดียวในโค้ด C++ ที่ดูเหมือนไม่มีอันตรายนั้น สามารถเปลี่ยนโปรแกรมที่มีประสิทธิภาพให้กลายเป็นฝันร้ายด้านประสิทธิภาพได้อย่างเงียบๆ ข้อผิดพลาดเล็กๆ น้อยๆ นี้ที่นักพัฒนาเผลอคัดลอกโครงสร้างข้อมูลขนาดใหญ่แทนที่จะส่งผ่านแบบ reference นั้น ถูกพบเห็นแม้แต่ในฐานโค้ดของบริษัทเทคโนโลยีใหญ่ๆ และยังคงสร้างปัญหาให้กับนักพัฒนา C++ ทั่วโลกอย่างต่อเนื่อง
ตัวฆ่าประสิทธิภาพเงียบๆ
ความแตกต่างระหว่าง void function(const Data d) และ void function(const Data& d) อาจดูเล็กน้อย แต่สามารถทำลายประสิทธิภาพของแอปพลิเคชันได้อย่างรุนแรง เวอร์ชันแรกจะสร้างสำเนาที่มีค่าใช้จ่ายสูงของโครงสร้างข้อมูลทั้งหมดทุกครั้งที่ฟังก์ชันทำงาน ในขณะที่เวอร์ชันที่สองจะส่งผ่าน reference อย่างมีประสิทธิภาพ ข้อผิดพลาดเพียงตัวอักษรเดียวนี้มักจะไม่ถูกสังเกตจนกว่าลูกค้าจะร้องเรียนเรื่องซอฟต์แวร์ช้า หรือจนกว่าจะมีคนมาทำ profile โค้ดในที่สุด
สิ่งที่ทำให้ข้อผิดพลาดนี้อันตรายเป็นพิเศษคือ ทั้งสองเวอร์ชันสามารถ compile ได้โดยไม่มี warning และดูเหมือนจะทำงานได้อย่างถูกต้อง การลดประสิทธิภาพจะเห็นได้ชัดเจนเมื่อต้องจัดการกับโครงสร้างข้อมูลขนาดใหญ่ หรือเมื่อฟังก์ชันถูกเรียกใช้บ่อยๆ ใน loop ที่ต้องการประสิทธิภาพสูง
การเปรียบเทียบการส่งผ่านพารามิเตอร์ระหว่าง C++ กับ Rust
| ด้าน | C++ | Rust |
|---|---|---|
| การส่งผ่านแบบค่า | void func(Data d) - คัดลอกเสมอ |
fn func(d: Data) - ย้ายตามค่าเริ่มต้น |
| การส่งผ่านแบบอ้างอิง | void func(const Data& d) - ไม่มีการคัดลอก |
fn func(d: &Data) - ยืม |
| การตรวจจับการคัดลอก | ต้องใช้ runtime/profiling | ข้อผิดพลาดในเวลา compile หากไม่ได้ตั้งใจ |
| พฤติกรรมเริ่มต้น | คัดลอก (อาจมีค่าใช้จ่ายสูง) | ย้าย (ประสิทธิภาพที่เหมาะสม) |
วิธีที่การออกแบบของ Rust ป้องกันกับดักนี้
Rust ใช้แนวทางที่แตกต่างโดยพื้นฐานซึ่งทำให้ข้อผิดพลาดประเภทนี้เกิดขึ้นได้ยากกว่ามาก โดยค่าเริ่มต้น Rust จะ move object เมื่อส่งผ่านแบบ by value แทนที่จะคัดลอก เว้นแต่ type นั้นจะ implement Copy trait เป็นการเฉพาะ ซึ่งหมายความว่านักพัฒนาจะได้ประสิทธิภาพที่เหมาะสมโดยค่าเริ่มต้นโดยไม่ต้องจำ syntax พิเศษ
เมื่อนักพัฒนา Rust ต้องการส่งผ่าน reference พวกเขาต้องใช้สัญลักษณ์ & อย่างชัดเจน เมื่อต้องการ ownership พวกเขาจะส่งผ่านแบบ by value compiler จะบังคับใช้ semantic เหล่านี้อย่างเข้มงวด โดยจับข้อผิดพลาดตั้งแต่เวลา compile แทนที่จะปล่อยให้ลื่นไถลเข้าไปในโค้ดที่ใช้งานจริง
Rust ป้องกันไม่ให้เราเขียนเวอร์ชันที่ไม่เหมาะสมของฟังก์ชัน C++ โดยไม่ตั้งใจ โดยมีข้อแม้ว่าตัวเลือกนี้แพร่กระจายไปทั่วทั้งภาษา ซึ่งอาจทำให้เกิดความไม่เข้าใจหรือสับสนได้
คุณสมบัติด้านความปลอดภัยหลักของ Rust
- การย้ายเป็นค่าเริ่มต้น: ประเภทที่ไม่ใช่ Copy จะถูกย้ายแทนที่จะคัดลอกเมื่อส่งผ่านตามค่า
- การติดตามความเป็นเจ้าของในเวลาคอมไพล์: ป้องกันข้อผิดพลาดการใช้งานหลังจากย้ายที่ C++ อนุญาต
- การคัดลอกแบบชัดเจน: ต้องใช้
.clone()เพื่อคัดลอก ทำให้การดำเนินการที่มีต้นทุนสูงมองเห็นได้ - การบังคับใช้ระบบประเภท: ประเภทพารามิเตอร์ที่ไม่ตรงกันจะถูกตรวจจับในเวลาคอมไพล์ ไม่ใช่เวลารันไทม์
ผลกระทบในโลกแห่งความเป็นจริง
การอภิปรายในชุมชนเผยให้เห็นว่านี่ไม่ใช่แค่ปัญหาทางทฤษฎี นักพัฒนารายงานว่าเห็นข้อผิดพลาดนี้บ่อยครั้งในโค้ดที่ใช้งานจริง แม้จะมี code review และเครื่องมือ linting ปัญหานี้จะรุนแรงเป็นพิเศษในฐานโค้ดขนาดใหญ่ที่การลดประสิทธิภาพสามารถไม่ถูกสังเกตเป็นเดือนๆ
C++ มีวิธีแก้ไขเช่น การลบ copy constructor หรือใช้เครื่องมือเช่น clang-tidy เพื่อจับปัญหาเหล่านี้ อย่างไรก็ตาม สิ่งเหล่านี้ต้องการการตั้งค่า การกำหนดค่า และความระมัดระวังเพิ่มเติมที่ทีมพัฒนาหลายทีมไม่ได้รักษาไว้อย่างสม่ำเสมอ
เกินกว่าการแก้ไขง่ายๆ
การถกเถียงขยายไปเกินกว่าแค่ข้อผิดพลาดเฉพาะนี้ไปสู่คำถามที่กว้างขึ้นเกี่ยวกับปรัชญาการออกแบบภาษา นักพัฒนาบางคนโต้แย้งว่าการวัดประสิทธิภาพควรจับปัญหาเหล่านี้ได้ไม่ว่าจะใช้ภาษาใด คนอื่นๆ โต้แย้งว่าภาษาควรให้ค่าเริ่มต้นที่ปลอดภัยกว่าเพื่อป้องกันข้อผิดพลาดทั่วไปไม่ให้เกิดขึ้นตั้งแต่แรก
แนวทางของ Rust มาพร้อมกับการแลกเปลี่ยน แม้ว่าจะป้องกันกับดักหลายอย่างของ C++ แต่ก็นำความซับซ้อนของตัวเองมาด้วยผ่านแนวคิดเช่น ownership, borrowing และการจัดการ lifetime ภาษานี้บังคับให้นักพัฒนาคิดอย่างชัดเจนเกี่ยวกับการจัดการหน่วยความจำและ ownership ของข้อมูล ซึ่งอาจรู้สึกจำกัดเมื่อเปรียบเทียบกับความยืดหยุ่นของ C++
บทสรุป
ปัญหา ampersand นี้เน้นย้ำความตึงเครียดพื้นฐานในภาษาโปรแกรมมิ่งระบบ C++ ให้ความสำคัญกับความยืดหยุ่นและความเข้ากันได้แบบย้อนหลัง บางครั้งก็แลกกับความปลอดภัยและความง่ายในการใช้งาน Rust ให้ความสำคัญกับความปลอดภัยและประสิทธิภาพโดยค่าเริ่มต้น บางครั้งก็แลกกับ learning curve และความเร็วในการพัฒนา ขณะที่ทั้งสองภาษายังคงพัฒนาต่อไป ประสบการณ์ของชุมชนกับข้อผิดพลาดในโลกแห่งความเป็นจริงเหล่านี้ช่วยให้ข้อมูลสำหรับแนวทางปฏิบัติที่ดีกว่าและเครื่องมือสำหรับทุกคน
อ้างอิง: The repercussions of missing an Ampersand in C++ & Rust