lire mot par mot à partir du fichier en C ++

cette fonction devrait lire un fichier word en word
et il fonctionne jusqu'au dernier mot, où l'exécution s'arrête

void readFile(  )
{
    ifstream file;
    file.open ("program.txt");
    string word;
    char x ;
    word.clear();

    while ( ! file.eof() )
    {
        x = file.get();

        while ( x != ' ' )
        {
            word = word + x;
            x = file.get();
        }

            cout<< word <<endl;
            word.clear();

    }
}

tout voir quel est le problème et comment il peut être résolu??

source d'informationauteur M.Tamimi

c++

34

Tout d'abord, ne tourne pas en boucle while (!eof())il ne fonctionnera pas comme vous l'attendez, parce que le eofbit ne sera pas jusqu'à ce que après un échec de lire à la fin du fichier.

Deuxièmement, l'entrée normale de l'opérateur >> sépare sur les espaces et peuvent donc être utilisés pour lire des "mots":
```
std::string word;
while (file >> word)
{
    ...
}
```

J'ai édité la fonction pour vous,

void readFile()
{
    ifstream file;
    file.open ("program.txt");
    if (!file.is_open()) return;

    string word;
    while (file >> word)
    {
        cout<< word << '\n';
    }
}

2

ce que vous faites ici, c'est la lecture d'un caractère à la fois à partir du flux d'entrée et de supposer que tous les caractères entre " de " représenter un mot. MAIS il est peu probable d'être un "" après le dernier mot, donc c'est probablement pourquoi il ne fonctionne pas:
```
"word1 word2 word2EOF"
```

Si je peut je pouvais vous donner quelques nouvelles de code pour la même tâche, dans mon code, vous pouvez créer un "document" (pas vraiment)et il est sauvé, et peut être ouvert de nouveau. Il est également stockées sous forme de chaîne de fichier(pas un document).
Voici le code:

#include "iostream"

#include "windows.h"

#include "string"

#include "fstream"

using namespace std;

int main() {

string saveload;


cout << "---------------------------" << endl;
cout << "|enter 'text' to write your document    |" << endl;
cout << "|enter 'open file' to open the document |" << endl;
cout << "----------------------------------------" << endl;
while (true){
    getline(cin, saveload);

    if (saveload == "open file"){
        string filenamet;
        cout << "file name? " << endl;
        getline(cin, filenamet, '*');
        ifstream loadFile;

        loadFile.open(filenamet, ifstream::in);

        cout << "the text you entered was: ";

        while (loadFile.good()){

            cout << (char)loadFile.get();

            Sleep(100);
        }

        cout << "" << endl;

        loadFile.close();

    }

    if (saveload == "text") {
        string filename;
        cout << "file name: " << endl;
        getline(cin, filename,'*');
        string textToSave;
        cout << "Enter your text: " << endl;
        getline(cin, textToSave,'*');

        ofstream saveFile(filename);

        saveFile << textToSave;

        saveFile.close();

    }
}
return 0;
}

Il suffit de prendre ce code et de le modifier pour servir vos fins.
RÊVER EN GRAND,PENSEZ GRAND, GROS

Comme d'autres l'ont dit, vous êtes susceptible de lecture atteint la fin du fichier que vous êtes la seule vérification pour x != ' '. Au lieu de cela, vous devez également vérifier pour les expressions du FOLKLORE dans la boucle interne (mais dans ce cas, n'utilisez pas un char, mais suffisamment grand type):

while ( ! file.eof() )
{
    std::ifstream::int_type x = file.get();

    while ( x != ' ' && x != std::ifstream::traits_type::eof() )
    {
        word += static_cast<char>(x);
        x = file.get();
    }
    std::cout << word << '\n';
    word.clear();
}

Mais là encore, vous pouvez seulement employer le flux de streaming opérateurs, qui déjà séparés à l'espace (et de mieux tenir compte des espaces multiples et d'autres types de whitepsace):

void readFile(  )
{
    std::ifstream file("program.txt");
    for(std::string word; file >> word; )
        std::cout << word << '\n';
}

Et même encore plus, vous pouvez employer un algorithme standard pour se débarrasser du manuel de la boucle:

#include <algorithm>
#include <iterator>

void readFile(  )
{
    std::ifstream file("program.txt");
    std::copy(std::istream_iterator<std::string>(file), 
              std::istream_itetator<std::string>(), 
              std::ostream_iterator<std::string>(std::cout, "\n"));
}

Vous devez vous connecter pour publier un commentaire.