Utilisation incorrecte de SetPrecision

Question

Avec les 2 fonctions suivantes, concentrez-vous sur les lignes avec les * commentaires. Lorsque l'instruction cout < < s'exécute, aucune décimale n'est affichée. 3021680380/10000000 devient 302. au lieu de 302.1680.

void convert(){ 
    setprecision(4); //************************ 
    newFileTime = new double[numRec]; //*********** 
    newOffset = new int[numRec]; 
    newSize = new int[numRec]; 
    newNum = new int[numRec]; 
    newType = new int[numRec]; 
    newTime = new int[numRec]; 

    for(int i = 0; i<numRec; i++){ 
     newFileTime[i] = fileTime[i]/10000000; //********** 
     newOffset[i] = offset[i]/512; 
     newSize[i] = fileSize[i]/512; 
     newNum[i] = 0; 
     if(type[i] == "Write"){ 
      newType[i] = 0; 
     }else{ 
      newType[i] = 1; 
     } 
     newTime[i] = responseTime[i]/10000000; 
    } 
} 

void exports(){ 
    setprecision(4); //************** 
    ofstream fout; 
    fout.open("prxy_0.ascii"); 
    { 
    if(!fout){ 
      cout <<"File opening failed. \n"; 
     } 
    } 
    fout<< numRec <<endl; 

    for(int i = 0; i < numRec; i++){ 
     fout<< newFileTime[i] << " " << newNum[i] << " " << newOffset[i] << " " << newSize[i] << " " << newType[i] << " " << newTime[i]; 
     cout<< fileTime[i] << " " << newFileTime[i] <<endl; //********** 
     if(i != numRec - 1){ 
      fout<<endl; 
     } 
    } 
    fout.close(); 
} 

Des idées?

Answer 1

Chaque fois que vous divisez deux entiers, le résultat de cette expression est également un entier. La division entière est toujours arrondie vers le bas.

newFileTime[i] = fileTime[i]/10000000; 
    //    ^^^^^^^^^^^ ^^^^^^^^ 
    //     int   int 

Pour fixer votre expression, jeter un des opérandes à un double pour rendre la division une division à virgule flottante (utiliser une des possibilités suivantes):

newFileTime[i] = static_cast<double>(fileTime[i])/10000000; 
    // or 
    newFileTime[i] = fileTime[i]/10000000.0; 

S'il vous plaît noter que le réglage la précision vous oblige à mettre l'appel de std::setprecision(...) dans le flux pour lequel vous voulez définir la précision. , Cela crée seulement aussi la sortie précision (lors de l'écriture au flux), pas comment les calculs sont effectués:

std::cout << std::setprecision(4) << [some double values] 

Notez également que std::setprecision définit le nombre de digets magnificant plutôt que les décimales après la virgule . Donc, votre 302.1680 serait imprimé comme 302.2 (quatre chiffres maginificant). Pour définir un nombre fixe de chiffres après le point décimal, écrire aussi std::fixed au courant, que ce soit avant ou après std::setprecision:

std::cout << std::fixed << std::setprecision(4) << [some double values] 

Notez que ces configurations seront conservées pendant l'exécution de votre programme jusqu'à ce que vous changez eux encore. Pour les conserver localement dans une fonction, assurez-vous de restaurer la configuration une fois que vous avez terminé.

Bien sûr, std::cout était seulement un exemple de flux. La même chose s'applique pour l'écriture dans des fichiers (n'importe quel objet std::ostream).

Answer 2

Pas tout à fait ce que vous avez demandé (déjà répondu), mais ceci:

newFileTime = new double[numRec]; //*********** 
newOffset = new int[numRec]; 
newSize = new int[numRec]; 
newNum = new int[numRec]; 
newType = new int[numRec]; 
newTime = new int[numRec]; 

demande à être:

struct FileData 
{ 
    double fileTime; 
    int offset; 
    int size; 
    int num; 
    int type; 
    int time; 
}; 

FileData *newData = new FileData[numRec]; 

newData[i].fileTime = ... 

rend beaucoup plus facile à gérer la chose.