Pourquoi mon fichier de sortie vide dans ce programme simple en utilisant std::fstream?

J'essaie de comprendre comment lire les informations de la forme d'un fichier d'entrée et d'écrire des données dans un fichier de sortie. Je comprends comment lire un fichier et affichage de son contenu, mais je NE comprends pas comment écrire dans un fichier ou d'afficher son contenu. Mon programme fonctionne très bien mais quand je vérifie ma sortie de fichier txt, il n'y a rien dedans! Que pouvais-je fait de mal?
le fichier d'entrée contient 3.1415 2.718 1.414.

#include <iostream>
#include <fstream>
#include <iomanip>

using namespace std;

int main()
{
float fValue;
fstream inputFile;
ofstream outputFile;

inputFile.open("C:\\Users\\David\\Desktop\\inputFile.txt");
outputFile.open("C:\\Users\\David\\Desktop\\outputfile.txt");

cout << fixed << showpoint;
cout << setprecision(3);
cout << "Items in input-file:\t " << "Items in out-put File: " << endl;

inputFile >> fValue;    //gets the fiest value from the input

while (inputFile) //single loop that reads(from inputfile) and writes(to outputfile)    each number at a time.
{
    cout << fValue << endl; //simply prints the numbers for checking.
    outputFile << fValue << ", "; //writes to the output as it reads numbers from the input.
    inputFile >> fValue; //checks next input value in the file
}



outputFile.close();
inputFile.close();


int pause;
cin >> pause;

return 0;
}
  • Que le code est erroné, puisque vous avez cout << fValue deux fois sans inputFile >> fValue entre. Je serais prêt à parier que le fichier n'a pas pu ouvrir
  • Vous avez oublié de vérifier le code d'erreur après l'ouverture d'un fichier! 🙂 Il ne réussit pas toujours!
  • Votre code "fonctionne" pour moi (il écrit la première valeur deux fois).
InformationsquelleAutor DEdesigns57 | 2011-09-30
  1. 3

    Sur windows, il est probable que vous avez le fichier de sortie ouvert avec quelque chose comme le bloc-notes et votre programme C++ n'est pas de l'ouverture du fichier de sortie. Si il ne peut pas ouvrir le fichier, le ofstream::fonction d'ouverture en silence à l'échec. Vous devez vérifier l'état de outputFile après que vous tentez de l'ouvrir. Quelque chose comme

    outputFile.open("C:\\Users\\David\\Desktop\\outputfile.txt");
if (!outputFile) {
  cerr << "can't open output file" << endl;
}

    Si le statut de outputFile n'est pas ok, alors vous pouvez faire 

    outputfile << "foobar";

    et 

    outputfile.flush();

    jusqu'les vaches viennent à la maison et que vous n'aurez pas de sortie.

    • Ce qui semble probable pour moi. J'ai essayé le code (sur Linux/GCC) et il fonctionne très bien.
    • Le rinçage a résolu mon problème. outputfile.flush();
    InformationsquelleAutor David Nehme
  2. 2

    Comme David N. mentionné, fstreams de ne pas les jeter par défaut lorsque le fichier ne s'ouvre pas, ou le flux pénètre dans un mauvais état à un certain moment au cours de l'écriture. Vous pouvez les jeter sur erreur en définissant le ofstream::exceptions drapeau à "ofstream::failbit n' | ofstream::badbit'. Vous pouvez trouver plus d'informations sur le masque d'exception ici:

    http://www.cplusplus.com/reference/iostream/ios/exceptions/

    Il est recommandé de définir le masque d'exception pour l'échec, parce que a) il évite des conditions de course et b) exige que les erreurs soient traitées et c) permettra le déroulement de pile qui est souvent pratique dans de grands programmes.

    D'autre part, dans cette boucle:

    while (inputFile) 
{
...
}

    La condition que vous devriez vérifier est inputFile.eof(). Cependant, je voudrais vous suggérer de le faire "à La C++ Chemin":

    #include <iostream>
#include <fstream>
#include <iomanip>  
#include <algorithm>
#include <iterator>

using namespace std;

int main()
{
  float fValue;
  ifstream inputFile;
  ofstream outputFile;

  inputFile.open("input");  
  outputFile.open("output");

  //EDIT: this is optional, but recommended
  inputFile.exceptions(ifstream::badbit | ifstream::failbit);
  outputFile.exceptions(ofstream::badbit | ofstream::failbit);

  copy(istream_iterator<double>(inputFile)
       , istream_iterator<double>()
       , ostream_iterator<double>(outputFile, ", "));

  /*
  //EDIT: you can also check the status manually, but it looks more like C code:
  if(inputFile.bad() || outputFile.bad())
     return 1;
  */

  outputFile.close();
  inputFile.close();

  cin.ignore();

  return 0;

}

    Notez l'utilisation des itérateurs et les std::copy() algorithme plutôt que de lire directement à partir du flux. Si vous voulez imprimer le contenu d'un fichier directement à std::cout, alors vous pouvez faire ceci:

    copy(istream_iterator<char>(file), istream_iterator<char>(), ostream_iterator<char>(cout));

    Notez que, par défaut istream_iterators ignorer les espaces blancs, de sorte que vous avez à mettre en file >> noskipws dans le but d'éviter cela.

    HTH!

    Gred

    InformationsquelleAutor gred
  3. 1

    Vous devez fermer le fichier de sortie de la mémoire tampon pour être vidées dans le fichier avant d'effectuer votre demande de quitter.

    • Le destructeur de ofstream devrait le faire pour vous.
    • ... à moins que le demandeur est en regardant le fichier que vous venez d'où le code s'arrête...
    • l'ajout de la fermer() a TRAVAILLÉ, il a fait le tour et mon programme écrit pour le fichier txt. Maintenant, j'ai juste besoin d'afficher des données à partir de la sortie de mon écran.
    • AaronN: je ne pense pas que sur les implications de int pause; cin >> pause; Vous avez raison.
    • Au lieu de fermer le fichier, vous pouvez aussi simplement utiliser outputFile.flush() ou outputFile << endl; (endl forces une chasse d'eau, comme le fait de clôture)
    InformationsquelleAutor AaronN
  4. 1

    Le code ressemble à enregistrer quelque chose dans le fichier. La logique est tout faux, mais quelque chose devrait être là. Vérifiez les membres de votre flux. 

    cout << fixed << showpoint;
cout << setprecision(3);
cout << "Items in input-file:\t " << "outputFile: " << endl;

while (inputFile >> fValue) 
{
    cout << fValue << endl; //this confirms that the above code read from my text file.
    outputFile << fValue << '\n'
    if (!outputFile) {
        cout << "Error saving to file.\n";
        break;
    }
}
    • J'ai mis des commentaires pour expliquer ma logique, où est ma façon de penser worng exactement?
    • Ah, le code a été changé. La logique est bon maintenant, sauf que vous n'avez toujours pas de vérifier l'état des flux de sortie.
    InformationsquelleAutor Mooing Duck