Ostrzeżenie C ++: dzielenie podwójnego przez zero

Przypadek 1:

#include <iostream>

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

Kompiluje się bez żadnych ostrzeżeń i wydruków inf. OK, C ++ radzi sobie z dzieleniem przez zero ( zobacz na żywo ).

Ale,

Przypadek 2:

#include <iostream>

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

Kompilator daje następujące ostrzeżenie ( zobacz na żywo ):

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

Dlaczego kompilator daje ostrzeżenie w drugim przypadku?

Jest 0 != 0.0?

Edytować:

#include <iostream>

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

wynik:

Same

Dzielenie zmiennoprzecinkowe przez zero jest dobrze zdefiniowane przez IEEE i daje nieskończoność (dodatnią lub ujemną w zależności od wartości licznika ^{(lub NaNdla ± 0)} ).

W przypadku liczb całkowitych nie ma sposobu, aby przedstawić nieskończoność, a język definiuje operację tak, aby miała niezdefiniowane zachowanie, więc kompilator z łatwością próbuje odciągnąć Cię od tej ścieżki.

Jednak w tym przypadku, ponieważ licznikiem jest a double, dzielnik ( 0) również powinien zostać podwyższony do podwójnej wartości i nie ma powodu, aby dawać ostrzeżenie, nie dając ostrzeżenia, 0.0więc myślę, że jest to błąd kompilatora.

W standardowym C ++ oba przypadki są niezdefiniowanym zachowaniem . Wszystko może się zdarzyć, łącznie z formatowaniem dysku twardego. Nie należy oczekiwać ani polegać na „return inf. Ok” ani na jakimkolwiek innym zachowaniu.

Kompilator najwyraźniej decyduje się na ostrzeżenie w jednym przypadku, a nie w drugim, ale to nie znaczy, że jeden kod jest w porządku, a drugi nie. To tylko dziwactwo generowanych przez kompilator ostrzeżeń.

Ze standardu C ++ 17 [wyr.mul] / 4:

/Operator binarny daje iloraz, a %operator binarny zwraca resztę z dzielenia pierwszego wyrażenia przez drugie. Jeśli drugi argument operacji /lub %wynosi zero, zachowanie jest niezdefiniowane.

Moim najlepszym przypuszczeniem, aby odpowiedzieć na to konkretne pytanie, byłoby to, że kompilator emituje ostrzeżenie przed wykonaniem konwersji intdo double.

Tak więc kroki wyglądałyby tak:

1. Wyrażenie analizy
2. Operator arytmetyczny /(T, T2) , w którym T=double, T2=int.
3. Sprawdź, czy to std::is_integral<T2>::valuejest truei b == 0- to wyzwala ostrzeżenie.
4. Emituj ostrzeżenie
5. Wykonaj niejawną konwersję T2nadouble
6. Wykonaj dobrze zdefiniowany podział (ponieważ kompilator zdecydował się na użycie IEEE 754).

Jest to oczywiście spekulacja i opiera się na specyfikacjach zdefiniowanych przez kompilator. Ze standardowego punktu widzenia mamy do czynienia z możliwymi niezdefiniowanymi zachowaniami.

Należy pamiętać, że jest to oczekiwane zachowanie zgodnie z dokumentacją GCC
(przy okazji wydaje się, że ta flaga nie może być używana jawnie w GCC 8.1)

-Wdiv-by-zero
Ostrzega o dzieleniu liczby całkowitej w czasie kompilacji przez zero. To jest ustawienie domyślne. Aby zablokować komunikaty ostrzegawcze, użyj -Wno-div-by-zero. Nie ostrzega się przed dzieleniem zmiennoprzecinkowym przez zero, ponieważ może to być uzasadniony sposób uzyskania nieskończoności i NaN.

W tej odpowiedzi nie będę wchodził w porażkę UB / nie UB.

Chcę tylko na to zwrócić uwagę 0i jestem 0.0 inny, mimo że 0 == 0.0oceniam jako prawda. 0jest intliterałem i 0.0jest doubleliterałem.

Jednak w tym przypadku wynik końcowy jest taki sam: d/0jest dzieleniem zmiennoprzecinkowym, ponieważ djest podwójny, a więc 0jest niejawnie konwertowany na podwójny.

Uważam, że foo/0i foo/0.0to nie to samo. Mianowicie wynikowy efekt pierwszego (dzielenie całkowite lub zmiennoprzecinkowe) jest silnie zależny od typu foo, podczas gdy to samo nie dotyczy drugiego (zawsze będzie to dzielenie zmiennoprzecinkowe).

Nie ma znaczenia, czy którykolwiek z nich jest UB. Cytując standard:

Dopuszczalne niezdefiniowane zachowanie waha się od całkowitego zignorowania sytuacji z nieprzewidywalnymi skutkami, przez zachowanie podczas tłumaczenia lub wykonywania programu w udokumentowany sposób charakterystyczny dla środowiska (z lub bez wydania komunikatu diagnostycznego) , po przerwanie tłumaczenia lub wykonania (z wydaniem komunikatu diagnostycznego).

(Podkreślenie moje)

Rozważ ostrzeżenie „ sugeruj nawiasy wokół przypisania używanego jako wartość prawdy ”: Sposobem na poinformowanie kompilatora, że naprawdę chcesz użyć wyniku przypisania, jest wyraźne umieszczenie przypisania i dodanie nawiasów wokół przypisania. Wynikowa instrukcja ma ten sam efekt, ale informuje kompilator, że wiesz, co robisz. To samo można powiedzieć o foo/0.0: skoro wyraźnie mówisz kompilatorowi „To jest dzielenie zmiennoprzecinkowe” używając 0.0zamiast 0, kompilator ufa ci i nie wyśle ​​ostrzeżenia.

Wygląda to na błąd w gcc, dokumentacja -Wno-div-by-zero jasno mówi :

Nie ostrzegaj o dzieleniu liczby całkowitej w czasie kompilacji przez zero. Nie ostrzega się przed dzieleniem zmiennoprzecinkowym przez zero, ponieważ może to być uzasadniony sposób uzyskania nieskończoności i NaN.

a po zwykłych konwersjach arytmetycznych uwzględnionych w [wyraż.arith.conv] oba operandy będą podwójne :

Wiele operatorów binarnych, które oczekują operandów typu arytmetycznego lub wyliczeniowego, powoduje konwersje i zwraca typy wyników w podobny sposób. Celem jest uzyskanie wspólnego typu, który jest również typem wyniku. Ten wzorzec nazywa się zwykłymi konwersjami arytmetycznymi, które są zdefiniowane w następujący sposób:

...

- W przeciwnym razie, jeśli jeden z argumentów jest podwójny, drugi zostanie przekonwertowany na podwójny.

i [wyr.mul] :

Operandy * i / powinny mieć arytmetyczny lub nieograniczony typ wyliczenia; operandy% mają typ wyliczenia całkowitego lub nieograniczonego. Zwykłe konwersje arytmetyczne są wykonywane na operandach i określają typ wyniku.

W odniesieniu do tego, czy dzielenie zmiennoprzecinkowe przez zero jest niezdefiniowanym zachowaniem i jak radzą sobie z tym różne implementacje, wydaje mi się, że tutaj odpowiedź . TL; DR; Wygląda na to, że gcc jest zgodne z załącznikiem F wrt do dzielenia zmiennoprzecinkowego przez zero, więc wartość undefined nie odgrywa tutaj roli. W przypadku brzęku odpowiedź byłaby inna.

Dzielenie zmiennoprzecinkowe przez zero zachowuje się inaczej niż dzielenie liczby całkowitej przez zero.

W IEEE zmiennoprzecinkowych standardowe rozróżnia + inf i -Inf, natomiast całkowite nie można przechowywać w nieskończoność. Wynik dzielenia liczby całkowitej przez zero jest niezdefiniowanym zachowaniem. Dzielenie zmiennoprzecinkowe przez zero jest zdefiniowane przez standard zmiennoprzecinkowy i daje w wyniku + inf lub -inf.