Trouver la fin de stream pour les cin & ifstream?

Je suis moi-même par le biais d'un C++ texte livre que j'ai qu'une remise à niveau pour la programmation en C++. L'un des exemples de problèmes (sans trop entrer dans les détails) me veut définir une fonction qui peut être transmise ifstream ou cin (par exemple istream) comme argument. À partir de là, j'ai à lire le flux. La difficulté est, je ne peux pas trouver un moyen d'avoir cette un fonction de l'utilisation cin et ifstream pour trouver efficacement la fin du flux. À savoir,

while(input_stream.peek() != EOF)

n'est pas d'aller travailler pour cin. J'ai pu retravailler la fonction pour chercher une certaine expression (comme "#Fin de Stream#" ou quelque chose), mais je pense que c'est une mauvaise idée si le flux de fichier je passe a cette phrase exacte.

J'ai pensé à utiliser la fonction de surcharge, mais jusqu'à présent, le livre a mentionné quand il veut de moi. Je suis probablement mettre trop d'effort dans ce un problème pratique, mais j'aime bien le processus créatif et je suis curieux de savoir si il y a une façon de le faire sans surcharge.

Cochez cette question: stackoverflow.com/questions/3197025/...

OriginalL'auteur user435219 | 2010-08-30

  1. 5

    eof() ne travail pour cin. Vous faites quelque chose de mal; merci de poster votre code. Une commune de la pierre d'achoppement est que eof drapeau est après vous essayez de lire derrière la fin du cours d'eau.

    Voici une démonstration:

    #include <iostream>
#include <string>

int main( int, char*[] )
{
    std::string s;
    for ( unsigned n = 0; n < 5; ++n )
    {
        bool before = std::cin.eof();
        std::cin >> s;
        bool after = std::cin.eof();
        std::cout << int(before) << " " << int(after) << "  " << s << std::endl;
    }

    return 0;
}

    et sa sortie:

    D:>t
aaaaa
0 0  aaaaa
bbbbb
0 0  bbbbb
^Z
0 1  bbbbb
1 1  bbbbb
1 1  bbbbb

    (Expressions du FOLKLORE peuvent être générés avec Ctrl-Z sur Windows et Ctrl-D sur de nombreux autres Systèmes d'exploitation)

    Désolé pour la confusion, j'ai d'abord eu while(!input_stream.eof()) mais alors réalisé que j'avais écrit alors(input_stream.coup d'oeil != EOF) à la place. Peu importe, les deux méthodes fonctionnent avec ctrl+z (assez ironiquement, je viens de lire sur le caractère eof dans wikipedia). Merci pour l'aide atzz, et tout le monde!
    Préférez la conversion du flux pour une booléenne plus .eof ou .bad.

    OriginalL'auteur atzz

  2. 2

    Pourquoi ne pas std::cin.eof() travail? cin sera le signal de EOF lors de l'entrée standard stdin ferme, ce qui se produit lorsque l'utilisateur des signaux avec Ctrl+d (*nix) ou Ctrl+z (Windows), ou (dans le cas d'une canalisation du flux d'entrée) lorsque les canalisations de fichier se termine

    Sous Windows, il est Ctrl+Z, Ctrl+D est pour les systèmes basés sur UNIX.
    Oh, bon point; ajouté que, dans
    Ah, ça fonctionne en effet (bien Ctrl + Z pour windows en tout cas). Désolé, si il y a un peu de confusion que j'ai d'abord eu while(!input_stream.eof()) dans le post avant et modifié à tout(input_stream.peek() != EOF). En tout cas, 1 préoccupation que j'ai, sur l'utilisation de while(!input_stream.eof ()), c'est que lorsque la fonction lit le caractère EOF l'échec bit est défini pour input_stream. Est-ce censé arriver?
    oui, parce qu'il n'a pas pu lire les données, car il a atteint les expressions du FOLKLORE. EOF provoque presque toujours fail ainsi

    OriginalL'auteur Michael Mrozek

  3. 2

    Si vous utilisez un flux de données dans un contexte booléen, alors il va se convertir en une valeur qui est équivalent à true si elle n'a pas atteint les expressions du FOLKLORE, et false si une tentative a été faite pour lire au-delà des expressions du FOLKLORE (non c'est faux lui aussi si il y a eu un erreur de lecture du flux de données).

    Puisque la plupart des opérations d'e /s sur les cours d'eau de retour du flux (de sorte qu'ils peuvent être enchaînés). Vous pouvez faire votre opération de lecture et d'utiliser le résultat du test (comme ci-dessus).

    Donc un programme pour lire un flux de nombres à partir d'un flux:

    int main()
{
   int x;

   //Here we try and read a number from the stream.
   //If this fails (because of EOF or other error) an internal flag is set.
   //The stream is returned as the result of operator>>
   //So the stream is then being used in the boolean context of the while()
   //So it will be converted to true if operator>>  worked correctly.
   //                        or false if operator>> failed because of EOF
   while(std::cin >> x)
   {
       //The loop is only entered if operator>> worked correctly.
       std::cout << "Value: " << x << "\n";
   }

   //Exit when EOF (or other error).
}

    OriginalL'auteur Martin York