Peringatan C ++: pembagian dua kali lipat dengan nol

Kasus 1:

#include <iostream>

int main()
{
    double d = 15.50;
    std::cout<<(d/0.0)<<std::endl;
}

Ini mengkompilasi tanpa peringatan dan cetakan apa pun inf. OK, C ++ dapat menangani pembagian dengan nol, ( lihat langsung ).

Tapi,

Kasus 2:

#include <iostream>

int main()
{
    double d = 15.50;
    std::cout<<(d/0)<<std::endl;
}

Kompilator memberikan peringatan berikut ( lihat langsung ):

warning: division by zero [-Wdiv-by-zero]
     std::cout<<(d/0)<<std::endl;

Mengapa kompilator memberikan peringatan pada kasus kedua?

Apakah 0 != 0.0?

Edit:

#include <iostream>

int main()
{
    if(0 == 0.0)
        std::cout<<"Same"<<std::endl;
    else
        std::cout<<"Not same"<<std::endl;
}

keluaran:

Same

Pembagian floating point dengan nol didefinisikan dengan baik oleh IEEE dan memberikan tak terbatas (baik positif atau negatif sesuai dengan nilai pembilang ^{(atau NaNuntuk ± 0)} ).

Untuk integer, tidak ada cara untuk merepresentasikan infinity dan bahasanya mendefinisikan operasi untuk memiliki perilaku yang tidak terdefinisi sehingga compiler dengan senang hati mencoba untuk mengarahkan Anda keluar dari path tersebut.

Namun dalam kasus ini, karena pembilangnya adalah a double, divisor ( 0) harus dipromosikan menjadi double juga dan tidak ada alasan untuk memberikan peringatan di sini sementara tidak memberikan peringatan, 0.0jadi saya pikir ini adalah bug compiler.

Dalam Standar C ++, kedua kasus adalah perilaku yang tidak ditentukan . Apa pun dapat terjadi, termasuk memformat hard drive Anda. Anda tidak boleh mengharapkan atau mengandalkan "return inf. Ok" atau perilaku lainnya.

Kompiler tampaknya memutuskan untuk memberikan peringatan dalam satu kasus dan bukan yang lain, tetapi ini tidak berarti bahwa satu kode OK dan yang satu tidak. Ini hanyalah kekhasan dari generasi peringatan yang dibuat oleh kompiler.

Dari standar C ++ 17 [expr.mul] / 4:

/Operator biner menghasilkan hasil bagi, dan %operator biner menghasilkan sisa dari pembagian ekspresi pertama dengan yang kedua. Jika operan kedua dari /atau %nol, perilakunya tidak ditentukan.

Tebakan terbaik saya untuk menjawab pertanyaan khusus ini adalah bahwa kompiler mengeluarkan peringatan sebelum melakukan konversi intke double.

Jadi, langkah-langkahnya seperti ini:

1. Ekspresi parse
2. Operator aritmatika /(T, T2) , di mana T=double, T2=int.
3. Periksa std::is_integral<T2>::valueadalah truedan b == 0- pemicu peringatan ini.
4. Keluarkan peringatan
5. Lakukan konversi implisit T2kedouble
6. Lakukan pembagian yang terdefinisi dengan baik (karena compiler memutuskan untuk menggunakan IEEE 754).

Ini tentu saja spekulasi dan didasarkan pada spesifikasi yang ditentukan kompiler. Dari sudut pandang standar, kita berurusan dengan kemungkinan Perilaku Tidak Terdefinisi.

Perhatikan bahwa ini adalah perilaku yang diharapkan menurut dokumentasi GCC
(btw. Tampaknya tanda ini tidak dapat digunakan secara eksplisit di GCC 8.1)

-Wdiv-by-zero
Peringatkan tentang pembagian integer waktu kompilasi dengan nol. Ini default. Untuk menghambat pesan peringatan, gunakan -Wno-div-by-zero. Pembagian floating point dengan nol tidak diperingatkan, karena ini bisa menjadi cara yang sah untuk mendapatkan infinitas dan NaN.

Saya tidak akan masuk ke UB / bukan UB bencana di jawaban ini.

Saya hanya ingin menunjukkan itu 0dan 0.0 berbeda meskipun 0 == 0.0menilai benar. 0adalah intliteral dan 0.0merupakan doubleliteral.

Namun dalam kasus ini, hasil akhirnya sama: d/0adalah pembagian floating point karena dganda dan 0secara implisit diubah menjadi double.

Saya berpendapat bahwa foo/0dan foo/0.0yang tidak sama. Yakni, efek yang dihasilkan dari yang pertama (pembagian integer atau pembagian floating point) sangat tergantung pada jenisnya foo, sedangkan hal yang sama tidak berlaku untuk yang kedua (itu akan selalu menjadi pembagian floating point).

Apakah salah satu dari keduanya adalah UB tidak relevan. Mengutip standar:

Perilaku tidak terdefinisi yang diizinkan berkisar dari mengabaikan situasi sepenuhnya dengan hasil yang tidak dapat diprediksi, hingga berperilaku selama penerjemahan atau eksekusi program dengan cara yang terdokumentasi, karakteristik lingkungan (dengan atau tanpa penerbitan pesan diagnostik) , hingga menghentikan terjemahan atau eksekusi (dengan penerbitan dari pesan diagnostik).

(Penekanan saya)

Pertimbangkan peringatan " sarankan tanda kurung di sekitar tugas yang digunakan sebagai nilai kebenaran ": Cara untuk memberi tahu compiler bahwa Anda benar - benar ingin menggunakan hasil tugas adalah dengan menjadi eksplisit, dan menambahkan tanda kurung di sekitar tugas. Pernyataan yang dihasilkan memiliki efek yang sama, tetapi memberi tahu kompiler bahwa Anda tahu apa yang Anda lakukan. Hal yang sama dapat dikatakan tentang foo/0.0: Karena Anda secara eksplisit memberi tahu compiler "Ini adalah pembagian floating point" dengan menggunakan 0.0alih-alih 0, kompilator mempercayai Anda dan tidak akan mengeluarkan peringatan.

Ini terlihat seperti bug gcc, dokumentasinya dengan -Wno-div-by-zero jelas mengatakan :

Jangan memperingatkan tentang pembagian integer waktu kompilasi dengan nol. Pembagian floating-point dengan nol tidak diperingatkan, karena ini bisa menjadi cara yang sah untuk mendapatkan infinitas dan NaN.

dan setelah konversi aritmatika biasa yang tercakup dalam [expr.arith.conv] kedua operan akan menjadi dua kali lipat :

Banyak operator biner yang mengharapkan operan aritmatika atau tipe enumerasi menyebabkan konversi dan menghasilkan tipe hasil dengan cara yang sama. Tujuannya adalah untuk menghasilkan jenis yang sama, yang juga merupakan jenis hasil. Pola ini disebut konversi aritmatika biasa, yang didefinisikan sebagai berikut:

...

- Jika tidak, jika salah satu operand adalah double, operand lainnya harus diubah menjadi double.

dan [expr.mul] :

Operan dari * dan / harus memiliki jenis pencacahan aritmatika atau tidak terbatas; operan dari% harus memiliki tipe pencacahan integral atau tidak tercakup. Konversi aritmatika biasa dilakukan pada operan dan menentukan jenis hasilnya.

Sehubungan dengan apakah floating point dibagi nol adalah perilaku tidak terdefinisi dan bagaimana implementasi yang berbeda menghadapinya, tampaknya jawaban saya di sini . TL; DR; Sepertinya gcc sesuai dengan Lampiran F wrt ke floating point dibagi nol, jadi tidak ditentukan tidak berperan di sini. Jawabannya akan berbeda untuk dentang.

Pembagian floating point dengan nol berperilaku berbeda dari pembagian integer dengan nol.

The IEEE floating point membedakan standar antara inf + dan -inf, sementara bilangan bulat tidak bisa menyimpan tak terhingga. Pembagian bilangan bulat dengan hasil nol adalah perilaku yang tidak terdefinisi. Pembagian floating point dengan nol ditentukan oleh standar floating point dan menghasilkan + inf atau -inf.