While (( c = getc(fichier)) != EOF) boucle de ne pas arrêter l'exécution

Je ne peux pas comprendre pourquoi ma boucle while ne fonctionne pas. Le code fonctionne très bien sans elle... Le but du code est de trouver un message secret dans un fichier bin. Donc j'ai eu le code pour trouver les lettres, mais maintenant, quand je cherche à obtenir de la boucle jusqu'à la fin du fichier, il ne fonctionne pas. Je suis nouveau à cela. Ce que je fais mal?

main(){

FILE* message;
int i, start;
long int size;
char keep[1];

message = fopen("c:\\myFiles\\Message.dat", "rb");

if(message == NULL){
    printf("There was a problem reading the file. \n");
    exit(-1);
}

//the first 4 bytes contain an int that tells how many subsequent bytes you can throw away
fread(&start, sizeof(int), 1, message);
printf("%i \n", start); //#of first 4 bytes was 280
fseek(message, start, SEEK_CUR); //skip 280 bytes
keep[0] = fgetc(message); //get next character, keep it
printf("%c", keep[0]); //print character

while( (keep[0] = getc(message)) != EOF) {
    fread(&start, sizeof(int), 1, message);
    fseek(message, start, SEEK_CUR);
    keep[0] = fgetc(message);
    printf("%c", keep[0]);
}

fclose(message);

system("pause");
}

EDIT:

Après avoir regardé mon code dans le débogueur, il semble comme avoir "getc" dans la boucle while jeté le tout hors tension. Je l'ai fixée par la création d'un nouveau char appelé lettre, puis le remplacement de mon code:

fread(&start, sizeof(int), 1, message);
fseek(message, start, SEEK_CUR);

while( (letter = getc(message)) != EOF) {
    printf("%c", letter);
    fread(&start, sizeof(int), 1, message);
    fseek(message, start, SEEK_CUR);
}

Il fonctionne comme un charme maintenant. Toutes les suggestions sont bien sûr les bienvenus. Merci à tous.

Avez-vous essayé de remplacer la condition de la boucle avec la fonction feof?
Qui introduit une erreur, n'oubliez pas que feof() ne retourne true après en essayant de lire le dernier octet.
Vous n'avez pas dit nous ce qui ne fonctionne pas. Quels sont les résultats que vous obtenez, et quels sont les résultats que vous souhaitez obtenir? Cela va nous aider à vous aider à trouver la réponse.
Il n'y a aucun point en ayant un tableau qui est à seulement 1 élément - char keep et de se débarrasser de la [0] partout.
En fait, les garder doivent être un int à corriger. Voir JonathanLeffler de réponse. @User1695758, si la réponse de Jonathan prend soin de, s'il vous plaît assurez-vous de l'accepter.

OriginalL'auteur user1695758 | 2012-12-04

c file input output

16

La valeur de retour de getc() et de ses proches est une int, pas un char.

Si vous attribuer le résultat de getc() à un char, l'un des deux il se passe des choses quand il revient EOF:
- Si simple char est pas signé, puis EOF est converti à 0xFF, et 0xFF != Expressions du FOLKLORE, de sorte que la boucle se termine jamais.
- Si simple char est signé, puis EOF est équivalent à un caractère valide (dans le 8859-1 code jeu, ÿ, y tréma, U+00FF, la LETTRE minuscule LATINE Y TRÉMA), et la boucle peut mettre fin à début.
Compte tenu du problème que vous rencontrez, nous pouvons provisoirement suppose que vous avez plaine char comme un type non signé.

La raison que getc() et al retourner un int, c'est qu'ils ont pour retourner toutes les valeurs possibles qui peuvent s'adapter dans un char et aussi une valeur distincte, les expressions du FOLKLORE. Dans le C standard, il est dit:

ISO/IEC 9899:2011 §7.21.7.1 La fgetc() fonction

int fgetc(FILE *stream);

Si la fin de fichier indicateur pour le flux d'entrée pointé par stream n'est pas définie et un
le caractère suivant est présent, le fgetc fonction obtient le caractère de unsigned char converti en int ...

Si la fin de fichier indicateur pour le stream est activé, ou si le flux est en fin de fichier, à la fin de l'
fichier indicateur pour le flux est défini et le fgetc fonction retourne EOF.

Un libellé similaire s'applique à la getc() de la fonction et de la getchar() fonction: ils sont définis à se comporter comme le fgetc() fonction sauf que si getc() est mis en œuvre comme une macro, il peut prendre des libertés avec le flux de fichier argument qui ne sont normalement pas accordée aux macros standard — plus précisément, l'argument stream expression peut être évaluée plus d'une fois, afin de l'appelant getc() avec des effets secondaires (getc(fp++)) est très bête (mais le changement de fgetc() et il serait à l'abri, mais toujours excentrique).

Dans votre boucle, vous pouvez utiliser:
```
int c;

while ((c = getc(message)) != EOF) {
    keep[0] = c;
```
Cela préserve l'affectation à keep[0]; je ne suis pas sûr d'en avoir vraiment besoin.

Vous devriez vérifier les autres appels à fgets(), getc(), fread() pour s'assurer que vous obtenez ce que vous attendez comme entrée. Surtout sur entrée, vous ne pouvez pas vraiment se permettre d'ignorer ces contrôles. Plus tôt, plutôt que plus tard, quelque chose va mal se passer et si vous n'êtes pas religieusement la vérification de la déclaration des statuts, votre code est susceptible de se bloquer, ou tout simplement "aller mal".

+1 je me disais que c'était le problème, mais n'avait aucune idée de la manière de la formuler de manière aussi concise.
Upvoted trop. Vous recommandons de le lui dire explicitement comment les corriger (déclarer garder comme un int) donc il n'y a pas de raison de ne pas accepter la vôtre comme la réponse.
Merci!! Je comprends ce qui se passait beaucoup mieux maintenant.

OriginalL'auteur Jonathan Leffler
1

Il y a 256 char valeurs qui pourraient être retourné par getc() et stockées dans un char variable comme keep[0] (oui, je suis oversummarising sauvagement). Pour détecter de fin de fichier de manière fiable, EOF doit avoir une valeur différente de tous. C'est pourquoi getc() retourne int plutôt que char: parce que 257th valeur distincte pour EOF ne rentre pas dans une char.

Donc vous avez besoin pour stocker la valeur renvoyée par getc() dans un int au moins jusqu'à ce que vous vérifiez contre EOF:
```
int tmpc;
while( (tmpc = getc(message)) != EOF) {
    keep[0] = tmpc;
    ...
```
Peut-être au lieu de "... parce que 257 valeurs distinctes ne rentre pas dans une char". OP du système, certainement windows, char qui est signé t maintenez EOF qui est susceptible -1. Il est impossible de distinguer entre EOF et (char) 255.
En effet, c'est ce que distinct signifie.

OriginalL'auteur John Marshall

Vous devez vous connecter pour publier un commentaire.