Problème incroyable !!!

Bonjour j'utilise dev c++ et j'utilise le code - on ne peut plus simple - suivant :

#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{
float i=5;

while(i>-1){
i-=0.05;
cout<<i<<endl;           
}
   
    system("PAUSE");
}

Rien de difficile du tout !!!!

Cependant, lors de l'affichage, j'obtiens des valeurs telles : 0.5499999 (au lieu de 0.55)
et lorsque i devrait etre égal à 0, j'ai  : -9.30578e-007 !!!

Pourquoi ca fait ca ? (jai essayé de remplacé float par double, mais j'ai toujours le problème quand i devrait etre égal à 0!!!)

Au secours ! Je m'arrache les cheveux !  :cry:

PS : j'ai essayé de mettre à la place de float i=5 float i=5.0f, aucun changement.

De plus, si dans ma boucle je fais :
if(i==1.2){
cout<<"etape"<<endl;          
}
le texte etape ne s'affiche jamais à l'écran alors que l'on peut constater sur la console qu'on passe bien par la valeur 1.2 !!!

#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{
    float i=5.0f;

    while(i>=0.0f)
    {
        cout<<i<<endl;
        i-=0.05f;
    }
  
    system("PAUSE");
}


C++ (@++)
___________________________________________
Venez débattre de sujets touchant à la programmation ici

ca me change rien : compiler, et voyez à partir de 1 ce qui se passe !

Car la valeur 0.55 n'existe pas en informatique. C'est juste une approximation. Donc on utilise tjs une précision minimale (epsilon), et donc l'égalité entre floatant devient sous forme mathématique

x = y <=> | x - y | < epsilon

Exact, et la bibliothèque standard le fournie même :
std::numeric_limits<float>::epsilon()

ok, mais dites moi, est ce possible de surdéfinir l'opérateur == pour qu'il fasse cette opération avec epsilon = 0.001 ? et si oui, comment ? (car il faut qu'il reste correctement défini si on fait une égalité d'int)

C'est pas une bonne idée de chercher à résoudre ca de cette facon, car meme si c'était possible ca ne respecterait pas la sémantique de l'opérateur ==, | x - y | < epsilonest différent dex == y

Tu peux pas faire quelque chose qui permet de feinter l'approximation; genre

float i=...(5);
double palier = ...(0.05), etape = ...(1.2);
int limite = ...(-1);
int mult = (int)(1/palier);
i *=mult;

while(i>mult*i){
   i--;
   cout<<(double)(i/mult)<<endl;  

   if( (int)(etape * mult) == i)

    {    cout<<"Etape"<<endl;
    }
}
   
    system("PAUSE");
}

??

Mais dans ton cas, tu peux aussi travailler sur des entiers:

int i = 100;
while (i > -1)
{
i--;
std::cout << float(i) * 0.05 << std::endl;
}

Evidemment, si les perfs n'ont aucun intérets, car je suis pas sur que la convertion soit si rapide :)

ok merci de toute vos réponses :)

par contre serait-il possible de définir un opérateur tel ~= (inexistant pour le moment à ma ocnnaissance) afin de permettre cette approximation ?