while ((c = getchar()) != EOF) Pas appelé à disparaître

Je viens de lire "Le Langage de Programmation C" et je suis arrivé à cette partie d'entrées et de sorties.

J'ai lu d'autres fils en disant que la console ne reconnait pas entrer comme EOF. De sorte que je devrais utiliser CTRL + Z dans Windows ou CTRL + D sous Unix (ni de ceux qui travaille pour moi).

J'ai aussi lu d'autres gens qui demandent la même chose en disant qu'ils pourraient le faire fonctionner, le problème dans leurs codes a été syntaxe pas le programme n'est pas appelé à disparaître.

Est-il une autre solution?

C'est le code:

#include <stdio.h>
main()
{
    int nb, nl, nt, c;
    nb = 0;
    nl = 0;
    nt = 0;
    while ((c = getchar()) != '\n'){
        if (c == ' ')
            ++nb;
        else if (c == '\n')
            ++nl;
        else if (c == '\t')
            ++nt;
    }
    printf("Input has %d blanks, %d tabs, and %d newlines\n", nb, nt, nl);
}

Edit: Le \n était censé être une des expressions du FOLKLORE, j'ai été déconner avant que j'ai posté et j'ai oublié je l'ai changé 😛

Il ne fonctionne pas avec les expressions du FOLKLORE ni, je l'ai tout simplement ignorée.

En tout état de (c = getchar()) != '\n') , \n doit être EOF
Je ne vois pas != EOF dans votre code
votre code ci-dessus va accepter '\n' en tant que condition d'arrêt
Veuillez modifier votre question afin que nous puissions voir le code réel, vous êtes en cours d'exécution, qui sans doute ne fait référence à EOF. Copier-coller le code source; ne pas re-type. while ((c = getchar()) != EOF) doit de travail. Vous êtes sur Windows ou Unix/Linux? Décrire (dans votre question, pas une réponse à ce commentaire) exactement ce que l'entrée que vous donnez lorsque vous exécutez le programme.
- Je me connecter à Ubuntu avec mastic, pour moi CTRL+DD va envoyer un EOF condition.

OriginalL'auteur user2738586 | 2013-09-02

c eof

4
```
while ((c = getchar())  !=EOF) {


}
```
Puis utilisez Ctrl+Z ou F6 sur Windows

Suivante va attendre un \n ou EOF, qui vient d'abord
```
while((c = getchar()) != '\n' && c != EOF){

}
```
\n ne devrait pas être la condition d'arrêt parce que l'OP est destiné à compter le nombre de \n rencontré des personnages.

OriginalL'auteur P0W
4

Sur Windows, vous tapez Ctrl-Z sur une ligne (pas d'espaces ni de quoi que ce soit) et de type Retour après que. Sur Windows, vous pouvez techniquement ignorer les expressions du FOLKLORE et indicateur de continuer à lire les caractères, bien que cela ne s'applique pas à d'autres systèmes d'exploitation, car EOF signifie, en réalité, les expressions du FOLKLORE.

OriginalL'auteur
3
```
while ((c = getchar()) != '\n'){
    if (c == ' ')
        ++nb;
    else if (c == '\n')
        ++nl;
    else if (c == '\t')
        ++nt;
} 
```
Selon la condition dans ta boucle while, vous ne serez pas en mesure de compter le nombre de nouvelles lignes parce que vous arrêter de la while boucle lorsque l'utilisateur tape un caractère de nouvelle ligne ('\n')

Autres que que, en comptant les espaces vides et des onglets fonctionne très bien.

CTRL+Z, sera reconnue comme une des expressions du FOLKLORE dans windows. Mais afin de le reconnaître dans votre programme, utilisez la condition dans la boucle while comme ((c = getchar()) != EOF).
Maintenant, lorsque l'utilisateur appuie sur la combinaison de touches: CTRL+Z, Il sera d'entrée de la console comme des expressions du FOLKLORE, et le programme devrait la reconnaître comme une entrée de caractères.

Faire ce qui vous permettra de compter le nombre de lignes de l'entrée

Donc, ma suggestion est:
```
while ((c = getchar()) != EOF){
    if (c == ' ')
        ++nb;
    else if (c == '\n')
        ++nl;
    else if (c == '\t')
        ++nt;
} 
```
Vous avez tort - Ctrl+Z seront reconnus comme des expressions du FOLKLORE dans Windows. De l'essayer.
Yse, je le sais. juste missplace le " pas " de word.

OriginalL'auteur ANjaNA
2

Si vous êtes sur un système unix:

La seule façon de simuler EOF via le clavier alors que l'alimentation d'entrée pour le programme manuellement, appuyez sur CTRL+D

Ici sont un couple de méthodes de l'alimentation d'entrée de votre programme et être en mesure de signal EOF à la fin de l'entrée:
- Faire usage de la ici la chaîne format pour nourrir une représentation de chaîne de caractères d'un fichier dans le programme.
  
  ./myprog <<< "Voici une chaîne de travailler avec"
- Alternativement, vous pouvez également utiliser la redirection d'entrée à alimenter un fichier contenant les données d'entrée du programme.
  
  ./myprog < input.fichier
Une des méthodes énumérées ci-dessus va travailler avec le code suivant:
```
#include <stdio.h>
#ifndef EOF
#define EOF (-1)
#endif
int main(void)
{
    int nb, nl, nt, c;
    nb = 0;
    nl = 0;
    nt = 0;
    while ((c = getchar()) != EOF){
        if (c == ' ')
            ++nb;
        else if (c == '\n')
            ++nl;
        else if (c == '\t')
            ++nt;
    }
    printf("Input has %d blanks, %d tabs, and %d newlines\n", nb, nt, nl);
    return 0;
}
```
- Ne pas laisser les fenêtres de la partie. Pour simuler EOF sur le clavier sur windows, utilisez CTRL+Z combinaison de touches
Ne sais pas si la chaîne de format pour unix est disponible pour windows, mais la redirection d'entrée doit être similaire

Non, les fichiers n'ont pas toujours un "caractère EOF" à la fin. Windows fichiers texte parfois, mais les fichiers texte Unix n'en ont pas. Fin-de-fichier est un état, pas un personnage, et EOF est une valeur spéciale retourné par getchar() pour indiquer une fin de fichier ou une condition d'erreur. Control-D ou ctrl-Z n'a pas de "simuler des expressions du FOLKLORE"; ils déclenchent une fin-de-fichier de condition, ce qui provoque getchar() de retour EOF comme son résultat. (C'est pourquoi getchar() retourne un int plutôt qu'un char.)
Thompson Bon à savoir

OriginalL'auteur smac89
0

Changer la ligne
```
//Buggy, you want calculate the # of '\n' in loop body,
//so logically you shouldn't use it as a stop condition.
while ((c = getchar()) != '\n')
```
à
```
while ((c = getchar()) != EOF)
```
Et essayer de presse Ctrl + C dans votre fenêtre de console sur Windows. Il fonctionne sur ma plate-forme qui est en cours d'exécution Win7.

À l'aide de Ctrl-C est la solution triviale pour cela et de ne pas répondre à la question.

OriginalL'auteur Eric Z
0

Tout d'abord sur la touche Ctrl + Z qui permet d'imprimer ^Z puis appuyez sur Entrée pour aller à l'EOF..

OriginalL'auteur user3647605
0
```
    /* This program will calculate the number of blanks, tabs and new line in a text stream */

#include <stdio.h>

main () 
{
    int c,nl = 0, blank = 0, tab = 0; //Newline, blanks and tabs.
    while ((c = getchar()) != EOF) {
        if (c == '\n')
            ++nl;
        else if (c == '\t')
            ++tab;
        else if (c == ' ')
            ++blank;
}
    printf("Tabs = %d\nBlanks = %d\nNewLine = %d",tab, blank, nl);
}
```
J'ai écrit ce code et il fonctionne correctement sur Ubuntu. Comme il est similaire à ce que vous avez écrit, j'ai essayé le code et Ctrl-D fonctionne correctement sous UNIX.

J'ai testé le code suivant et avons réalisé que si nous sommes à l'entrée \n dans le flux de texte, il ne sera pas augmenter le compteur de la nouvelle ligne, en va de même pour un \t tabulation. Appuyez sur le bouton entrée pour la nouvelle ligne, et en appuyant sur la touche tab pour tab est pris en compte par le compteur c'est un point à noter.

Ce qui se passe, car en appuyant sur entrée se met un caractère de saut de ligne, qui est un caractère unique alors que la saisie \n est traitée différemment et ils sont en fait deux personnages.

Je pensais que cela va ajouter de la valeur à cette question, alors je lui ai expliqué ce truc aussi.
Merci.

OriginalL'auteur Darshit Mulani
-2

pour reconnaître les expressions du FOLKLORE en turbo c++ dans la fenêtre appuyez sur la touche Ctrl+z cela va agir comme des expressions du FOLKLORE dans le programme, puis de mettre fin au programme....avec la condition
while((c=getchar())!=EOF)

OriginalL'auteur Sohan Joshi

Vous devez vous connecter pour publier un commentaire.