Saya menemukan idiom pemrograman ini baru-baru ini:

const float Zero = 0.0;

yang kemudian digunakan dalam perbandingan:

if (x > Zero) {..}

Adakah yang bisa menjelaskan apakah ini benar-benar lebih efisien atau dapat dibaca atau dipelihara daripada:

if (x > 0.0) {..}

CATATAN: Saya dapat memikirkan alasan lain untuk mendefinisikan konstanta ini, saya hanya ingin tahu tentang penggunaannya dalam konteks ini .

Kemungkinan alasannya adalah jenis caching, penamaan atau pemaksaan

Caching (tidak berlaku)

Anda ingin menghindari biaya membuat objek selama tindakan perbandingan. Di Jawa contohnya adalah

BigDecimal zero = new BigDecimal ("0.0");

ini melibatkan proses pembuatan yang cukup berat dan lebih baik dilayani menggunakan metode statis yang disediakan:

BigDecimal zero = BigDecimal.ZERO;

Ini memungkinkan perbandingan tanpa menimbulkan biaya pembuatan berulang karena BigDecimal sudah di-cache oleh JVM selama inisialisasi.

Dalam hal apa yang telah Anda gambarkan, primitif melakukan pekerjaan yang sama. Ini sebagian besar berlebihan dalam hal caching dan kinerja.

Penamaan (tidak mungkin)

Pengembang asli berupaya memberikan konvensi penamaan yang seragam untuk nilai-nilai umum di seluruh sistem. Ini memiliki beberapa kelebihan, terutama dengan nilai-nilai yang tidak biasa tetapi sesuatu yang mendasar seperti nol hanya sepadan dengan kasus caching sebelumnya.

Jenis pemaksaan (kemungkinan besar)

Pengembang asli berupaya untuk memaksa tipe primitif tertentu untuk memastikan bahwa perbandingan dilakukan pada tipe yang benar dan mungkin ke skala tertentu (jumlah tempat desimal). Ini OK, tetapi nama sederhana "nol" mungkin tidak cukup detail untuk kasus penggunaan ini dengan ZERO_1DP sebagai ekspresi maksud yang lebih tepat.

Itu karena "Tooling Nagging"

Kemungkinan alasan yang tidak saya lihat tercantum di sini adalah karena banyak alat berkualitas menandai penggunaan angka ajaib . Seringkali merupakan praktik yang buruk untuk memiliki angka ajaib yang dilemparkan ke dalam algoritma tanpa membuatnya terlihat jelas untuk perubahan nanti, terutama jika mereka digandakan di beberapa tempat dalam kode.

Jadi, walaupun alat ini benar dalam menandai masalah seperti itu, mereka sering menghasilkan positif palsu untuk situasi di mana nilai-nilai ini tidak berbahaya dan kemungkinan besar bersifat statis, atau hanya menjadi nilai inisialisasi.

Dan ketika itu terjadi, kadang-kadang Anda menghadapi pilihan:

• menandainya sebagai false positive, jika alat memungkinkan (biasanya dengan komentar yang diformat khusus, yang menjengkelkan bagi orang-orang TIDAK menggunakan alat)
• atau mengekstraksi nilai-nilai ini ke konstanta, apakah itu penting atau tidak.

Tentang Kinerja

Tergantung pada bahasa saya kira, tetapi ini cukup umum di Jawa dan tidak memiliki dampak kinerja, karena nilai-nilai yang diuraikan pada waktu kompilasi jika mereka adalah konstanta nyata static final. Ini tidak akan berdampak pada C atau C ++ jika mereka dinyatakan sebagai konstanta atau bahkan sebagai makro pra-prosesor.

Ini mungkin masuk akal karena secara eksplisit didefinisikan Zerosebagai tipe float.

Setidaknya dalam C dan C ++ nilainya 0.0bertipe double, sedangkan yang setara floatadalah 0.0f. Jadi dengan asumsi xAnda membandingkan terhadap juga selalu floatmengatakan

x > 0.0

sementara benar-benar mempromosikan xuntuk doublemencocokkan jenis 0.0yang dapat menyebabkan masalah (dengan tes kesetaraan khususnya). Perbandingan tanpa konversi tentunya

x > 0.0f

yang melakukan hal yang sama seperti

float Zero = 0.0; // double 0.0 converted to float  
x > Zero

Namun demikian, saya pikir akan jauh lebih berguna untuk mengaktifkan peringatan konversi di kompiler daripada meminta pengguna menulis kode yang aneh.

Pertama-tama, di sini nol didefinisikan sebagai float, bukan int. Tentu saja, ini tidak mempengaruhi apa pun dalam perbandingan, tetapi dalam kasus lain ketika konstanta ini digunakan, itu mungkin membuat perbedaan.

Saya tidak melihat alasan lain mengapa Zerodinyatakan konstan di sini. Ini hanya beberapa gaya pengkodean, dan lebih baik untuk mengikuti gaya jika digunakan di tempat lain dalam program tertentu.

Ini hampir pasti sama efisiennya selama eksekusi (kecuali jika kompiler Anda sangat primitif) dan sedikit kurang efisien selama kompilasi.

Mengenai apakah itu lebih mudah dibaca daripada x > 0... ingat bahwa ada orang-orang yang jujur, dengan tulus, berpikir bahwa COBOL adalah ide bagus dan kesenangan untuk bekerja dengan - dan kemudian ada orang yang berpikir persis sama tentang C. (Rumor memiliki bahwa bahkan ada beberapa programmer dengan pendapat yang sama tentang C ++!) Dengan kata lain, Anda tidak akan mendapatkan kesepakatan umum tentang hal ini, dan mungkin tidak layak diperebutkan.

Ini benar-benar lebih efisien atau dapat dibaca atau dipelihara daripada:

if (x > 0.0) {..}

Jika Anda menulis kode generik (yaitu non-tipe-spesifik), maka sangat mungkin. Suatu zero()fungsi dapat berlaku untuk semua jenis aljabar, atau jenis apa pun yang merupakan penambahan grup. Ini bisa berupa bilangan bulat, bisa berupa nilai titik-mengambang, bahkan bisa menjadi fungsi jika variabel Anda, katakanlah, itu sendiri adalah fungsi dalam beberapa ruang linear (mis. X adalah fungsi linear dari bentuk z -> a_x * z + b_x) dan kemudian zero()menyediakan fungsi dengan a dan b keduanya zero()dari jenis yang mendasarinya.

Jadi Anda akan mengharapkan kode seperti itu, katakanlah, C ++ mungkin (meskipun zero()AFAIK tidak terlalu umum), atau di Julia, dan mungkin bahasa lain.