Discussion :

[devroot]

Bonjour,

Je tombe sur un curieux problème de conversion de double à int.
Voici mon code (C++ builder)...
Avec le debugger jevois que C est égal à 3 qui est effectivement le résultat de 0.15 divisé par 0.05.
MAIS, en convertissant C à res donc double vers int, res finit avec une valeur de... 2 !?!?

Ce code donne quoi chez vous ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
int _tmain(int argc, _TCHAR* argv[])
{
		double A=0.15, B=0.05, C;
		C=A/B;
		int res=(int)C;
		return 0;
}

[devroot]

Je me réponds à moi-même :

J'ai trouvé la solution suivante :
C++11 added lround that helps to avoid precision loss on implicit double to long truncating cast:
int intValue = (int) lround(dblValue)

... MAIS ça ne m'explique en rien le problème :
Le double 3.00 ne fait pas l'objet d'un arrondi pour finir correctement en int avec une valeur de 3, n'est-ce pas ?

Alors pourquoi le problème se pose-t-il ?

[WhiteCrow]

Bonjour et bonne année,

il s'agit simplement d'un problème lié à la représentation des flottants. Teste avec le code suivant, tu comprendras mieux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
#include <stdio.h>
 
int main(void)
{
    double A=0.15;
    double B=0.05;
    double C=A/B;
 
    printf("A=%lf\nB=%lf\nC=%lf\n\n", A, B, C);
    printf("A=%.20lf\nB=%.20lf\nC=%.20lf\n\n", A, B, C);
    printf("(int) C = %d\n\n", (int) C);
 
    return 0;
}

Ta sortie devrait ressembler à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
A=0.150000
B=0.050000
C=3.000000
 
A=0.14999999999999999445
B=0.05000000000000000278
C=2.99999999999999955591
 
(int) C = 2

Du coup avec le transtypage de double vers int, la valeur est tronquée : tu obtiens 2.

Peut-être que la fonction lrint conviendrait mieux dans ton cas d'utilisation, non ?

[Bousk]

Le cast en int tronque.
Si tu veux faire un arrondi mathématique, une méthode simple est d'ajouter 0.5 avant.
int res = (int)(C + 0.5);

[devroot]

Merci à tous les deux pour vos solutions. J'applique et ça marche.

Il subsiste tout de même dans mon esprit une incompréhension...
Pour résumer, un double semble défini presque aléatoirement si l'on va jeter un coup d'oeil aux chiffres loin derrière la virgule ?
C'est pour ça que l'on prend soin de définir un double =1.0 et pas simplement =1 ?
Alors pour être 100% certain de ma definition de valeur je devrais écrire =1.0000000000000000 ?

[WhiteCrow]

Les flottants utilisent une représentation en base 2. Tout comme en base 10 où, par exemple, 1/3 n'a pas une représentation finie (⇒ 0,33333.....), 15/100 (=0,15) n'a pas une représentation finie en base 2 (0,00 1001 1001 1001 ....) d'où la valeur 0,14999999999999999445 affichée lorsque cette représentation est «convertie» en base 10 à nouveau. C'est le flottant le plus proche de 0,15(base 10) représentable en base 2.

[devroot]

Merci WhiteCrow. C'est clair !

[Sve@r]

Bonjour

C'est pour ça que l'on prend soin de définir un double =1.0 et pas simplement =1 ?

Non, c'est juste une question de convention et de lisibilité. Ecrire double d=1.0 ou double d=1 ne change rien mais la première écriture sera plus rapidement assimilé par un autre lecteur du code "ah oui d est un double" (ok c'est écrit mais ça ne coûte rien de le redire).
On peut aussi écrire "1.0" au lieu de "1" dans un calcul pour forcer le calcul à se faire en virgule flottante. Par exemple généralement on écrira x/2.0 plutôt que x/2 pour être sûr que la division de fasse en précision double et non int.