Avviso C ++: divisione del doppio per zero

Caso 1:

#include <iostream>

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

Si compila senza avvisi e stampa inf. OK, C ++ può gestire la divisione per zero, ( guardalo dal vivo ).

Ma,

Caso 2:

#include <iostream>

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

Il compilatore dà il seguente avviso ( guardalo dal vivo ):

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

Perché il compilatore dà un avviso nel secondo caso?

È 0 != 0.0?

Modificare:

#include <iostream>

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

produzione:

Same

La divisione in virgola mobile per zero è ben definita da IEEE e fornisce l'infinito (positivo o negativo in base al valore del numeratore ^{(o NaNper ± 0)} ).

Per i numeri interi, non c'è modo di rappresentare l'infinito e il linguaggio definisce l'operazione in modo che abbia un comportamento indefinito, quindi il compilatore cerca utilmente di allontanarti da quel percorso.

Tuttavia in questo caso, poiché il numeratore è a double, anche il divisore ( 0) dovrebbe essere promosso a doppio e non c'è motivo di dare un avviso qui senza dare un avviso per 0.0quindi penso che questo sia un bug del compilatore.

In Standard C ++, entrambi i casi sono un comportamento non definito . Può succedere di tutto, inclusa la formattazione del disco rigido. Non dovresti aspettarti o fare affidamento su "return inf. Ok" o qualsiasi altro comportamento.

Apparentemente il compilatore decide di dare un avvertimento in un caso e non nell'altro, ma questo non significa che un codice sia OK e l'altro no. È solo una stranezza della generazione di avvisi del compilatore.

Dallo standard C ++ 17 [expr.mul] / 4:

L' /operatore binario restituisce il quoziente e l' %operatore binario restituisce il resto dalla divisione della prima espressione per la seconda. Se il secondo operando di /o %è zero il comportamento non è definito.

La mia ipotesi migliore per rispondere a questa particolare domanda sarebbe che il compilatore emetta un avviso prima di eseguire la conversione di intin double.

Quindi, i passaggi sarebbero come questo:

1. Parse espressione
2. Operatore aritmetico /(T, T2) , dove T=double, T2=int.
3. Verificare che std::is_integral<T2>::valuesia truee b == 0- questo attiva un avviso.
4. Emetti un avviso
5. Eseguire la conversione implicita di T2indouble
6. Eseguire una divisione ben definita (poiché il compilatore ha deciso di utilizzare IEEE 754).

Questa è ovviamente una speculazione e si basa su specifiche definite dal compilatore. Dal punto di vista standard, abbiamo a che fare con possibili comportamenti indefiniti.

Si noti che questo è un comportamento previsto secondo la documentazione di GCC
(a proposito, sembra che questo flag non possa essere utilizzato esplicitamente in GCC 8.1)

-Wdiv-by-zero
Avvisa della divisione intera per zero in fase di compilazione. Questa è l'impostazione predefinita. Per inibire i messaggi di avviso, utilizzare -Wno-div-by-zero. La divisione in virgola mobile per zero non è avvertita, in quanto può essere un modo legittimo per ottenere infiniti e NaN.

Non entrerò nella debacle di UB / non UB in questa risposta.

Voglio solo sottolineare questo 0e 0.0 sono diversi nonostante 0 == 0.0valutino vero. 0è un intletterale ed 0.0è un doubleletterale.

Tuttavia in questo caso il risultato finale è lo stesso: d/0è una divisione in virgola mobile perché dè double e quindi 0viene convertito implicitamente in double.

Direi che foo/0e nonfoo/0.0 sono la stessa cosa. Vale a dire, l'effetto risultante della prima (divisione intera o divisione in virgola mobile) dipende fortemente dal tipo di , mentre lo stesso non è vero per la seconda (sarà sempre una divisione in virgola mobile).foo

Se qualcuno dei due è UB è irrilevante. Citando lo standard:

Il comportamento indefinito ammissibile va dall'ignorare completamente la situazione con risultati imprevedibili, al comportamento durante la traduzione o l'esecuzione del programma in modo documentato caratteristico dell'ambiente (con o senza l'emissione di un messaggio diagnostico) , al termine di una traduzione o esecuzione (con l'emissione di un messaggio diagnostico).

(Enfasi mia)

Considera l' avvertimento " suggerisci parentesi attorno all'assegnazione usata come valore di verità ": il modo per dire al compilatore che vuoi veramente usare il risultato di un compito è essere espliciti e aggiungere parentesi attorno all'assegnazione. L'istruzione risultante ha lo stesso effetto, ma dice al compilatore che sai cosa stai facendo. Lo stesso si può dire su foo/0.0: poiché stai dicendo esplicitamente al compilatore "Questa è una divisione in virgola mobile" usando 0.0invece di 0, il compilatore si fida di te e non emetterà un avviso.

Sembra un bug di gcc, la documentazione di -Wno-div-by-zero dice chiaramente :

Non avvisare della divisione di interi in fase di compilazione per zero. La divisione in virgola mobile per zero non è avvertita, in quanto può essere un modo legittimo per ottenere infiniti e NaN.

e dopo le consuete conversioni aritmetiche descritte in [expr.arith.conv] entrambi gli operandi saranno doppi :

Molti operatori binari che prevedono operandi di tipo aritmetico o di enumerazione causano conversioni e producono tipi di risultati in modo simile. Lo scopo è produrre un tipo comune, che è anche il tipo del risultato. Questo modello è chiamato le solite conversioni aritmetiche, che sono definite come segue:

...

- Altrimenti, se uno degli operandi è double, l'altro deve essere convertito in double.

e [expr.mul] :

Gli operandi di * e / devono avere un tipo di enumerazione aritmetica o senza ambito; gli operandi di% devono avere un tipo di enumerazione integrale o senza ambito. Le consuete conversioni aritmetiche vengono eseguite sugli operandi e determinano il tipo di risultato.

Riguardo al fatto che la divisione in virgola mobile per zero sia un comportamento indefinito e il modo in cui la diversa implementazione lo gestisce sembra la mia risposta qui . TL; DR; Sembra che gcc sia conforme all'Allegato F rispetto alla divisione in virgola mobile per zero, quindi undefined non gioca un ruolo qui. La risposta sarebbe diversa per clang.

La divisione in virgola mobile per zero si comporta in modo diverso dalla divisione intera per zero.

Lo standard in virgola mobile IEEE distingue tra + inf e -inf, mentre gli interi non possono memorizzare l'infinito. Il risultato della divisione intera per zero è un comportamento indefinito. La divisione in virgola mobile per zero è definita dallo standard in virgola mobile e risulta in + inf o -inf.