Pourquoi le résultat de l'arithmétique double est-il faux?

Question

Je donne les résultats suivants, en C++:

double clsTime::dblSSM(INT16U uint16Hrs, INT16U uint16Mins, INT16U uint16Secs, INT16U uint16Hunds) { 
     double dblHrsAsSecs = (double)(uint16Hrs % 24) * 3600.0 
       ,dblMinsAsSecs = (double)(uint16Mins % 60) * 60.0 
       ,dblSecs  = (double)(uint16Secs % 60) 
       ,dblHundreths = (double)(uint16Hunds % 100)/100.0 
       ,dblSSM = dblHrsAsSecs + dblMinsAsSecs + dblSecs + dblHundreths;  
     return dblSSM;      
    } 

Lorsque vous appelez cette fonction avec:

dblResult = dblSSM(16, 56, 17, 13); 

Je peux voir dans le débogueur que les résultats des variables intermédiaires sont les suivantes:

dblHrsAsSecs = 57600 
    dblMinsAsSecs = 3360 
    dblSecs  = 17 
    dblHundreths = 0.13 

Cependant, lorsqu'il est combiné en dblSSM, le résultat est:

60977.1 

Ce que je veux est: 60977.13 qui est la bonne réponse, pourquoi le .03 étant abandonné et comment puis-je l'obtenir inclus?

Pour convertir en une chaîne pour la vérification:

void clsTime::ssmToString(double dblSSM, char* pszBuffer, char szFormat[]) { 
     INT8U uint8Hours, uint8Minutes, uint8Seconds, uint8Hundreths; 
     double dblDummy; 

     assert(pszBuffer != NULL); 
     long lngSSM = (long)dblSSM; 
     uint8Hours = (INT8U)(lngSSM/((long)mscuint16SecsInHour)); 
     uint8Minutes = (INT8U)((lngSSM % ((long)mscuint16SecsInHour))/
               (long)mscuint16SecsInMinute); 
     uint8Seconds = (INT8U)(lngSSM % (long)mscuint16SecsInMinute); 
     int8Hundreths = (INT8U)(modf(dblSSM, &dblDummy) * 100.0); 
     sprintf(pszBuffer, szFormat, uint8Hours, uint8Minutes 
         , uint8Seconds, uint8Hundreths); 
    } 

szFormat est un paramètre optionnel, la valeur par défaut transmis est:

"%02.2u:%02.2u:%02.2u.%02.2u" 

Answer 1

Je pense que ce n'est pas le résultat mais votre problème d'impression.
J'ai écrit ce programme:

#include <iostream> // cout 
#include <iomanip> // fixed, setprecision 

using namespace std; 

double dblSSM(__uint16_t uint16Hrs, __uint16_t uint16Mins, __uint16_t uint16Secs, __uint16_t uint16Hunds) { 
     double dblHrsAsSecs = (double)(uint16Hrs % 24) * 3600.0 
       ,dblMinsAsSecs = (double)(uint16Mins % 60) * 60.0 
       ,dblSecs  = (double)(uint16Secs % 60) 
       ,dblHundreths = (double)(uint16Hunds % 100)/100.0 
       ,dblSSM = dblHrsAsSecs + dblMinsAsSecs + dblSecs + dblHundreths;  
     return dblSSM;      
    } 

int main() { 

    cout << dblSSM(16, 56, 17, 13) << endl; // prints 60977.1 
    cout << fixed << setprecision(8)/*output 8 in the decimal part */ << dblSSM(16, 56, 17, 13) << endl; // prints 60977.13000000 

    return 0; 
} 

Je pense que cela fonctionne comme il se doit.
Si vous souhaitez imprimer en double, vous devez utiliser setprecision et fixed.

EDIT:

cout << fixed << setprecision(12) << (modf(dblSSM, &dblDummy) * 100.0); 

impressions 12.999999999738 si (__uint16_t)(modf(dblSSM, &dblDummy) * 100.0) donne 12. façon Hacky de résoudre ce problème est d'utiliser la fonction round, mais je vous suggère de ne pas utiliser doubles, sauf si vous avez vraiment.