est (0,1 + 0,2) == 0,3 vrai ou faux?

J'obtiens false pour votre programme, pas true comme vous l'indiquez dans votre question. ( 0.3 est un littéral double , donc je suppose que lorsque vous avez testé cela localement, vous avez utilisé une variable float au lieu d'un 0.3 littéral.) Si vous utilisez réellement float ( == 0.3f au lieu de == 0.3 ), vous obtenez true comme sortie car il se trouve qu'avec float , 0,1 + 0,2 == 0,3 est vrai.

Mais strong>, le point fondamental reste que le IEEE-754 à virgule flottante binaire utilisé par float (simple précision) et double (double précision) est très rapide à calculer et utile pour beaucoup de choses, mais par nature imprécis pour certaines valeurs, et donc vous obtenez ce genre du problème. Avec float , vous obtenez true pour 0,1 + 0,2 == 0,3 , mais vous obtenez false pour 0,1 + 0,6 == 0,7 :

#include <stdio.h>

int main() {
    printf("%s\n", 0.1 + 0.2 == 0.3 ? "true" : "false"); // prints false
    //             ^^^−−−^^^−−−−^^^−−− `double` literals
    return 0;
}

Le célèbre 0.1 + 0.2 == 0.3 version de ce problème arrive à double:

#include <stdio.h>

int main() {
    printf("%s\n", 0.1f + 0.6f == 0.7f ? "true" : "false"); // prints false
    //             ^^^^−−−^^^^−−−−^^^^−−− `float` literals
    return 0;
}

Généralement, toutes les rvaleurs float sont déclarées comme double (par exemple 0.5, 11.332, 8.9, etc.) Ainsi, lorsque vous écrivez l'instruction suivante:

0.10000000000000000555 // 0.1
0.2000000000000000111  // 0.2
0.2999999999999999889  // 0.3 -------- NOTE
0.30000000000000004441 // 0.1 + 0.2 -- NOTE

Il évalue 0,1 + 0,2 = 0,3, c'est correct, mais dans le côté droit, le 0.3 ne fonctionne pas comme vous vous attendez à ce qu'il soit, comme déjà mentionné, il est déclaré comme double par défaut.

Ainsi, le compilateur essaie de comparer la valeur:

#include <iomanip>
.
.
.
cout << setprecision(20) << 0.1 << endl;
cout << setprecision(20) << 0.2 << endl;
cout << setprecision(20) << 0.3 << endl;
cout << setprecision(20) << (0.1 + 0.2) << endl;

Ce qui n'est clairement pas égal. p >

Pour résoudre ce problème, vous devez ajouter un suffixe pour exprimer le compilateur que vous essayez d'utiliser une valeur à virgule flottante.

Essayez plutôt ceci:

(a + b == 0.3F)

Au sens mathématique, 0,1 + 0,2 == 0,3 est toujours vrai

Au sens de virgule flottante, 0,1 + 0,2 == 0,3 n'est vrai que si erreur de représentation de 0,1 + erreur de représentation de 0,2 == erreur de représentation de 0,3

Comme je suis sûr que vous le savez, les erreurs dépendent de la valeur et de son ampleur. En tant que tel, il existe quelques cas où les erreurs s'alignent de telle sorte que les nombres à virgule flottante semblent fonctionner pour l'égalité, mais le cas général est que de telles comparaisons en général sont erronées, car elles ne tiennent pas compte des erreurs.

Pour écrire du code à virgule flottante fort, vous devez vous pencher sur la théorie des mesures et savoir comment propager les erreurs de mesure dans vos formules. Cela signifie également que vous devrez remplacer l'égalité de type C (comparaison de bits) par un "égal dans les limites de l'erreur".

Notez que vous ne pouvez pas construire un système qui gère automatiquement l'erreur dans le programme parfaitement, car cela nécessiterait une approche de stockage exacte de taille finie pour tout nombre fractionnaire de chiffres répétitifs éventuellement infinis. En conséquence, l'estimation d'erreur est généralement utilisée, et le résultat est généralement comparé dans une limite d'approximation qui est ajustée pour les valeurs impliquées.

Il ne faut pas longtemps pour se rendre compte que même si votre programme est correct, vous ne pouvez pas faire confiance à la technique car la technique, en général, ne retournera pas les bonnes valeurs.