Avertissement C ++: division du double par zéro

Cas 1:

#include <iostream>

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

Il compile sans aucun avertissement et imprime inf. OK, C ++ peut gérer la division par zéro, ( voir en direct ).

Mais,

Cas 2:

#include <iostream>

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

Le compilateur donne l'avertissement suivant ( voyez-le en direct ):

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

Pourquoi le compilateur donne-t-il un avertissement dans le second cas?

Est-ce 0 != 0.0?

Éditer:

#include <iostream>

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

production:

Same

La division en virgule flottante par zéro est bien définie par IEEE et donne l'infini (positive ou négative selon la valeur du numérateur ^{(ou NaNpour ± 0)} ).

Pour les entiers, il n'y a aucun moyen de représenter l'infini et le langage définit l'opération comme ayant un comportement indéfini afin que le compilateur essaie utilement de vous éloigner de ce chemin.

Cependant dans ce cas, puisque le numérateur est a double, le diviseur ( 0) devrait également être promu au double et il n'y a aucune raison de donner un avertissement ici sans donner d'avertissement pour 0.0donc je pense que c'est un bogue du compilateur.

En C ++ standard, les deux cas sont des comportements indéfinis . Tout peut arriver, y compris le formatage de votre disque dur. Vous ne devez pas vous attendre ou compter sur "return inf. Ok" ou tout autre comportement.

Le compilateur décide apparemment de donner un avertissement dans un cas et pas dans l'autre, mais cela ne signifie pas qu'un code est OK et l'autre ne l'est pas. C'est juste une bizarrerie de la génération d'avertissements du compilateur.

À partir de la norme C ++ 17 [expr.mul] / 4:

L' /opérateur binaire donne le quotient et l' %opérateur binaire donne le reste de la division de la première expression par la seconde. Si le deuxième opérande de /ou %est égal à zéro, le comportement n'est pas défini.

Ma meilleure supposition pour répondre à cette question particulière serait que le compilateur émette un avertissement avant d' effectuer la conversion de inten double.

Ainsi, les étapes seraient comme ceci:

1. Expression d'analyse
2. Opérateur arithmétique /(T, T2) , où T=double, T2=int.
3. Vérifiez que std::is_integral<T2>::valuec'est trueet b == 0- cela déclenche un avertissement.
4. Émettre un avertissement
5. Effectuer une conversion implicite de T2endouble
6. Effectuer une division bien définie (puisque le compilateur a décidé d'utiliser IEEE 754).

Ceci est bien sûr une spéculation et est basé sur des spécifications définies par le compilateur. Du point de vue standard, nous traitons d'éventuels comportements indéfinis.

Veuillez noter que c'est un comportement attendu selon la documentation de GCC
(btw. Il semble que cet indicateur ne puisse pas être utilisé explicitement dans GCC 8.1)

-Wdiv-by-zero
Avertir de la division par zéro au moment de la compilation. C'est par défaut. Pour empêcher les messages d'avertissement, utilisez -Wno-div-by-zero. La division en virgule flottante par zéro n'est pas mise en garde, car elle peut être un moyen légitime d'obtenir des infinis et des NaN.

Je n'entrerai pas dans la débâcle UB / non UB dans cette réponse.

Je veux juste souligner cela 0et 0.0 sont différents malgré l' 0 == 0.0évaluation vraie. 0est un intlittéral et 0.0est un doublelittéral.

Cependant, dans ce cas, le résultat final est le même: d/0est une division en virgule flottante car elle dest double et 0est donc implicitement convertie en double.

Je dirais que foo/0et nefoo/0.0 sont pas les mêmes. À savoir, l'effet résultant du premier (division entière ou division en virgule flottante) dépend fortement du type de foo, alors qu'il n'en est pas de même pour le second (ce sera toujours une division en virgule flottante).

Que l'un des deux soit UB n'est pas pertinent. Citant la norme:

Le comportement indéfini autorisé va de l'ignorance totale de la situation avec des résultats imprévisibles, au comportement pendant la traduction ou l'exécution du programme d'une manière documentée caractéristique de l'environnement (avec ou sans l'émission d'un message de diagnostic) , à la fin d'une traduction ou d'une exécution (avec l'émission d'un message de diagnostic).

(Je souligne le mien)

Considérez l' avertissement « suggérer des parenthèses autour de l'affectation utilisée comme valeur de vérité »: La façon de dire au compilateur que vous voulez vraiment utiliser le résultat d'une affectation est d'être explicite et d'ajouter des parenthèses autour de l'affectation. L'instruction résultante a le même effet, mais elle indique au compilateur que vous savez ce que vous faites. La même chose peut être dite à propos de foo/0.0: Puisque vous dites explicitement au compilateur "Ceci est une division en virgule flottante" en utilisant à la 0.0place de 0, le compilateur vous fait confiance et n'émettra pas d'avertissement.

Cela ressemble à un bogue gcc, la documentation de -Wno-div-by-zero dit clairement :

N'avertissez pas de la division par zéro au moment de la compilation. La division en virgule flottante par zéro n'est pas mise en garde, car elle peut être un moyen légitime d'obtenir des infinis et des NaN.

et après les conversions arithmétiques habituelles couvertes dans [expr.arith.conv] les deux opérandes seront doubles :

De nombreux opérateurs binaires qui attendent des opérandes de type arithmétique ou énumération provoquent des conversions et produisent des types de résultats de la même manière. Le but est de produire un type commun, qui est également le type du résultat. Ce modèle est appelé les conversions arithmétiques habituelles, qui sont définies comme suit:

...

- Sinon, si l'un des opérandes est double, l'autre doit être converti en double.

et [expr.mul] :

Les opérandes de * et / doivent avoir un type d'énumération arithmétique ou sans portée; les opérandes de% doivent être de type énumération intégrale ou non cadrée. Les conversions arithmétiques usuelles sont effectuées sur les opérandes et déterminent le type du résultat.

En ce qui concerne la question de savoir si la division en virgule flottante par zéro est un comportement indéfini et la manière dont une implémentation différente la traite, je pense que ma réponse ici . TL, DR; Il semble que gcc soit conforme à l' Annexe F en ce qui concerne la division en virgule flottante par zéro, donc undefined ne joue pas un rôle ici. La réponse serait différente pour clang.

La division en virgule flottante par zéro se comporte différemment de la division entière par zéro.

La norme de virgule flottante IEEE fait la différence entre + inf et -inf, tandis que les entiers ne peuvent pas stocker l'infini. La division entière par zéro est un comportement indéfini. La division en virgule flottante par zéro est définie par la norme à virgule flottante et donne + inf ou -inf.