Pas exactement convertit du double en int - semble problème est dans les instructions CPU

Question

J'ai été surpris quand j'ai débogué mon code. Ici, je donne un exemple de code

#include<QMessageBox> 
#include<iostream> 
#include<math.h> 
#include<QApplication> 
using namespace std; 

class MyMessageBox: public QMessageBox 
{ 
    public: 
     MyMessageBox(string message,QWidget *parent=0) : 
      QMessageBox(
       QMessageBox::NoIcon, 
       QString("ErrorMessage"), 
       QString(message.c_str()), 
       QMessageBox::Ok, 
       parent, 
       Qt::Widget) 
     { 
     } 
}; 

void Hai() 
{ 
    int tempi = 4; 
    double a = pow(10,tempi); 
    int temp = int(pow(10,tempi)); 

    //int temp=a; 

    MyMessageBox mb1((QString::number(pow(10,tempi))+ 
         " *** "+ 
         QString::number(temp)).toStdString()); 
    mb1.exec(); 
} 

int main(int argc, char * argv[]) 
{ 

    QApplication app(argc,argv); 
    Hai(); 

    return app.exec(); 
} 

et le résultat est,

10000 *** 9999 

Et le point principal est, cette chose ne se produit que pour l'alimentation 4 (= pow (x, 4), et non pour tout autre pouvoirs

EDIT:.

J'ai essayé un minimum de code avec Visual studio, mais il donne 10 000 exactement, mais, il n'a jamais compilé jusqu'à ce que je fait le type c. onversion explicitement. Le code est donné ci-dessous

#include<iostream> 
#include<math.h> 

using namespace std; 

void Hai() 
{ 
    int tempi = 4; 
    double a=pow(10.0,tempi); 
    int temp=pow(10.0,tempi); 

    cout << " a " << a << " temp " << temp << endl ; 
} 

int main(int argc, char * argv[]) 
{ 
    Hai(); 
    return 1; 
} 

Answer 1

Votre problème est que le résultat de votre opération en virgule flottante est 9999,9999999 ... donc int(...) est int(9999.9999999...) qui, bien sûr, est 9999. Depuis que les opérations à virgule flottante sont rarement exacte, vous ne doit pas écrire votre code pour attendre qu'ils soient. Dans ce cas, vous pouvez utiliser une fonction d'arrondi.

Comme cela a été souligné dans le commentaire, il est extrêmement improbable que votre implémentation de pow(10,4) ne produise pas un nombre entier positif, donc votre exemple est probablement erroné. Cependant, le point demeure: ne vous attendez jamais à ce que les résultats à virgule flottante soient exacts.

Voir aussi: why is 1.2 * 30 = 35?

Answer 2

Rappelez-vous pow (10,4) et pow (10.0,4) et pow (10.0,4.0) ne pas appeler la même fonction.

Answer 3

Aucune norme ne garantit la précision de la fonction pow. Les vendeurs de librairies responsables essaient d'obtenir des cas simples et précis comme celui-ci, mais vous ne pouvez pas en dépendre (comme le montre votre expérience) si vous voulez écrire du bon code portable.

Si vous souhaitez calculer de petites puissances entières exactement, calculez-les avec une multiplication répétée (ou avec une fonction de bibliothèque prévue à cet effet), et non avec un appel à pow.