Ampersand (&) yang hilang dalam kod C++ nampaknya tidak berbahaya tetapi boleh secara senyap mengubah program yang cekap menjadi mimpi ngeri prestasi. Bug halus ini, di mana pembangun secara tidak sengaja menyalin struktur data yang besar daripada menghantar melalui rujukan, telah ditemui walaupun dalam pangkalan kod syarikat teknologi utama dan terus melanda pembangun C++ di seluruh dunia.
Pembunuh Prestasi Senyap
Perbezaan antara void function(const Data d) dan void function(const Data& d) mungkin kelihatan remeh, tetapi ia boleh memusnahkan prestasi aplikasi. Versi pertama mencipta salinan mahal bagi keseluruhan struktur data setiap kali fungsi dijalankan, manakala yang kedua menghantar rujukan dengan cekap. Kesilapan satu aksara ini sering tidak disedari sehingga pelanggan mengadu tentang perisian yang perlahan atau seseorang akhirnya membuat profil kod tersebut.
Apa yang menjadikan bug ini sangat berbahaya ialah kedua-dua versi dikompil tanpa amaran dan kelihatan berfungsi dengan betul. Penalti prestasi hanya menjadi jelas apabila berurusan dengan struktur data yang besar atau apabila fungsi dipanggil kerap dalam gelung kritikal prestasi.
Perbandingan Pemindahan Parameter C++ vs Rust
| Aspek | C++ | Rust |
|---|---|---|
| Lulus mengikut nilai | void func(Data d) - Sentiasa menyalin |
fn func(d: Data) - Bergerak secara lalai |
| Lulus mengikut rujukan | void func(const Data& d) - Tiada salinan |
fn func(d: &Data) - Meminjam |
| Pengesanan salinan | Memerlukan masa jalan/profil | Ralat masa kompil jika tidak disengajakan |
| Tingkah laku lalai | Salin (berpotensi mahal) | Bergerak (prestasi optimum) |
Bagaimana Reka Bentuk Rust Mencegah Perangkap Ini
Rust mengambil pendekatan yang berbeza secara asas yang menjadikan jenis kesilapan ini lebih sukar dilakukan. Secara lalai, Rust memindahkan objek apabila menghantar melalui nilai daripada menyalinnya, melainkan jenis tersebut secara khusus melaksanakan trait Copy. Ini bermakna pembangun mendapat prestasi optimum secara lalai tanpa perlu mengingati sintaks khas.
Apabila pembangun Rust ingin menghantar rujukan, mereka mesti menggunakan simbol & secara eksplisit. Apabila mereka ingin mengambil pemilikan, mereka menghantar mengikut nilai. Pengkompil menguatkuasakan semantik ini dengan ketat, menangkap kesilapan pada masa kompil daripada membiarkannya tergelincir ke dalam kod pengeluaran.
Rust menghalang kita daripada secara tidak sengaja menulis versi sub-optimum fungsi C++ dengan kaveat bahawa pilihan ini merebak ke seluruh bahasa, yang boleh menjadi tidak intuitif atau mengelirukan.
Ciri-ciri Keselamatan Utama Rust
- Pemindahan secara lalai: Jenis bukan- Copy dipindahkan dan bukannya disalin apabila dihantar mengikut nilai
- Penjejakan pemilikan masa kompilasi: Menghalang pepijat penggunaan-selepas-pemindahan yang dibenarkan oleh C++
- Penyalinan eksplisit: Mesti menggunakan
.clone()untuk menyalin, menjadikan operasi mahal kelihatan - Penguatkuasaan sistem jenis: Jenis parameter yang tidak sepadan ditangkap pada masa kompilasi, bukan masa jalan
Kesan Dunia Sebenar
Perbincangan komuniti mendedahkan bahawa ini bukan sekadar masalah teori. Pembangun melaporkan melihat kesilapan ini kerap dalam kod pengeluaran, walaupun dengan semakan kod dan alat linting. Isu ini menjadi sangat bermasalah dalam pangkalan kod yang besar di mana kemerosotan prestasi boleh tidak disedari selama berbulan-bulan.
C++ memang menawarkan penyelesaian seperti memadamkan konstruktor salinan atau menggunakan alat seperti clang-tidy untuk menangkap isu ini. Walau bagaimanapun, ini memerlukan persediaan tambahan, konfigurasi, dan kewaspadaan yang tidak dikekalkan secara konsisten oleh banyak pasukan pembangunan.
Melangkaui Pembetulan Mudah
Perdebatan meluas melangkaui bug khusus ini kepada soalan yang lebih luas tentang falsafah reka bentuk bahasa. Sesetengah pembangun berpendapat bahawa mengukur prestasi sepatutnya menangkap isu ini tanpa mengira bahasa yang digunakan. Yang lain berpendapat bahawa bahasa sepatutnya menyediakan lalai yang lebih selamat untuk mencegah kesilapan biasa daripada berlaku sejak awal.
Pendekatan Rust datang dengan pertukaran. Walaupun ia mencegah banyak perangkap C++, ia juga memperkenalkan kerumitannya sendiri melalui konsep seperti pemilikan, peminjaman, dan pengurusan jangka hayat. Bahasa ini memaksa pembangun berfikir secara eksplisit tentang pengurusan memori dan pemilikan data, yang boleh terasa terhad berbanding fleksibiliti C++.
Kesimpulan
Isu ampersand ini menyerlahkan ketegangan asas dalam bahasa pengaturcaraan sistem. C++ mengutamakan fleksibiliti dan keserasian ke belakang, kadangkala dengan mengorbankan keselamatan dan kemudahan penggunaan. Rust mengutamakan keselamatan dan prestasi secara lalai, kadangkala dengan mengorbankan keluk pembelajaran dan kelajuan pembangunan. Semasa kedua-dua bahasa terus berkembang, pengalaman komuniti dengan bug dunia sebenar ini membantu memaklumkan amalan dan perkakas yang lebih baik untuk semua orang.
Rujukan: The repercussions of missing an Ampersand in C++ & Rust