Aviso C ++: divisão de duplo por zero

Caso 1:

#include <iostream>

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

Compila sem avisos e imprime inf. OK, C ++ pode lidar com divisão por zero, ( veja ao vivo ).

Mas,

Caso 2:

#include <iostream>

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

O compilador dá o seguinte aviso ( veja ao vivo ):

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

Por que o compilador dá um aviso no segundo caso?

É 0 != 0.0?

Editar:

#include <iostream>

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

resultado:

Same

A divisão de ponto flutuante por zero é bem definida pelo IEEE e dá infinito (positivo ou negativo de acordo com o valor do numerador ^{(ou NaNpara ± 0)} ).

Para inteiros, não há como representar o infinito e a linguagem define a operação como tendo um comportamento indefinido, portanto, o compilador tenta ajudar você a desviá-lo desse caminho.

No entanto, neste caso, uma vez que o numerador é um double, o divisor ( 0) deve ser promovido a um duplo também e não há razão para dar um aviso aqui, embora não seja um aviso para, 0.0então acho que este é um bug do compilador.

No C ++ padrão, ambos os casos são comportamento indefinido . Tudo pode acontecer, incluindo a formatação do seu disco rígido. Você não deve esperar ou confiar em "return inf. Ok" ou qualquer outro comportamento.

O compilador aparentemente decide dar um aviso em um caso e não no outro, mas isso não significa que um código está OK e o outro não. É apenas uma peculiaridade da geração de avisos do compilador.

Do padrão C ++ 17 [expr.mul] / 4:

O /operador binário produz o quociente, e o %operador binário produz o resto da divisão da primeira expressão pela segunda. Se o segundo operando de /ou %for zero, o comportamento é indefinido.

Meu melhor palpite para responder a essa pergunta em particular seria que o compilador emite um aviso antes de realizar a conversão de intpara double.

Então, as etapas seriam assim:

1. Expressão de análise
2. Operador aritmética /(T, T2) , onde T=double, T2=int.
3. Verifique se std::is_integral<T2>::valueé truee b == 0- isso dispara um aviso.
4. Aviso de emissão
5. Execute a conversão implícita de T2paradouble
6. Execute uma divisão bem definida (já que o compilador decidiu usar IEEE 754).

É claro que isso é especulação e se baseia em especificações definidas pelo compilador. Do ponto de vista padrão, estamos lidando com possíveis comportamentos indefinidos.

Observe que este é o comportamento esperado de acordo com a documentação do GCC
(aliás, parece que este sinalizador não pode ser usado explicitamente no GCC 8.1)

-Wdiv-by-zero Avisa
sobre a divisão inteira por zero em tempo de compilação. Este é o padrão. Para inibir as mensagens de aviso, use -Wno-div-by-zero. A divisão de ponto flutuante por zero não é alertada, pois pode ser uma forma legítima de obter infinitos e NaNs.

Não vou entrar no desastre UB / não UB nesta resposta.

Eu só quero apontar isso 0e 0.0 são diferentes apesar de 0 == 0.0avaliarem como verdade. 0é um intliteral e 0.0é um doubleliteral.

No entanto, neste caso, o resultado final é o mesmo: d/0é uma divisão em ponto flutuante porque dé dupla e, portanto, 0está implicitamente convertida em dupla.

Eu argumentaria isso foo/0e nãofoo/0.0 são os mesmos. Ou seja, o efeito resultante da primeira (divisão inteira ou divisão de ponto flutuante) é altamente dependente do tipo de , enquanto o mesmo não é verdade para a segunda (será sempre uma divisão de ponto flutuante).foo

Se algum dos dois é UB é irrelevante. Citando o padrão:

O comportamento indefinido permissível varia de ignorar a situação completamente com resultados imprevisíveis, para se comportar durante a tradução ou execução do programa de maneira documentada característica do ambiente (com ou sem a emissão de uma mensagem de diagnóstico) , para encerrar uma tradução ou execução (com a emissão de uma mensagem de diagnóstico).

(Ênfase minha)

Considere o aviso " sugira parênteses em torno da atribuição usada como valor verdade ": a maneira de dizer ao compilador que você realmente deseja usar o resultado de uma atribuição é sendo explícito e adicionando parênteses ao redor da atribuição. A instrução resultante tem o mesmo efeito, mas informa ao compilador que você sabe o que está fazendo. O mesmo pode ser dito sobre foo/0.0: Como você está explicitamente dizendo ao compilador "Esta é uma divisão de ponto flutuante" usando em 0.0vez de 0, o compilador confia em você e não emitirá um aviso.

Parece um bug do gcc, a documentação -Wno-div-by-zero diz claramente :

Não avise sobre a divisão inteira do tempo de compilação por zero. A divisão de ponto flutuante por zero não é alertada, pois pode ser uma forma legítima de obter infinitos e NaNs.

e após as conversões aritméticas usuais abordadas em [expr.arith.conv], ambos os operandos serão duplos :

Muitos operadores binários que esperam operandos do tipo aritmético ou enumeração causam conversões e produzem tipos de resultado de maneira semelhante. O objetivo é produzir um tipo comum, que também é o tipo do resultado. Esse padrão é chamado de conversões aritméticas usuais, que são definidas da seguinte maneira:

...

- Caso contrário, se um dos operandos for duplo, o outro deve ser convertido para duplo.

e [expr.mul] :

Os operandos de * e / devem ter tipo de enumeração aritmética ou sem escopo; os operandos de% devem ter tipo de enumeração integral ou sem escopo. As conversões aritméticas usuais são realizadas nos operandos e determinam o tipo de resultado.

Com relação a se a divisão de ponto flutuante por zero é um comportamento indefinido e como diferentes implementações lidam com isso, parece minha resposta aqui . TL; DR; Parece que o gcc está em conformidade com o Anexo F em relação ao ponto flutuante dividido por zero, portanto, undefined não desempenha um papel aqui. A resposta seria diferente para clang.

A divisão de ponto flutuante por zero se comporta de maneira diferente da divisão de inteiro por zero.

O padrão de ponto flutuante IEEE diferencia entre + inf e -inf, enquanto os inteiros não podem armazenar o infinito. A divisão inteira por resultado zero é um comportamento indefinido. A divisão de ponto flutuante por zero é definida pelo padrão de ponto flutuante e resulta em + inf ou -inf.