Vérifier la fin d'un fichier + 1

Linquisiteur -  
 Linquisiteur -
Bonjour, j'aimerais pouvoir vérifier si j'arrive à la fin d'un fichier. Je connais cette instrution:
while (!feof(fichierhexa))

Mais le problème est que dans le code situé dans la boucle je prend les 2 prochains char mais je ne vérifie pas si il y a encore au moins 2 char à lire dans mon fichier texte ce qui me ferrais au finale boucler.
Je souhaite une instruction a rajouter dans ce morceau de code ex:

while (!feof(fichierhexa)&&!feof(fichierhexa+1))


Modifier la position avec lseek serait peut être possible (pas encore tenter) mais vraiment pas propre et ne vérifierai pas si il n'y a que 1 lettre

Merci d'avance
A voir également:

2 réponses

fiddy Messages postés 11069 Date d'inscription   Statut Contributeur Dernière intervention   1 846
 
Bonjour,

j'aimerais pouvoir vérifier si j'arrive à la fin d'un fichier. Je connais cette instrution: while (!feof(fichierhexa))
Pas exactement. Cela permet de savoir si l'erreur de lecture rencontrée plus haut est due à la fin de fichier. Il faut donc tenter de lire la fin de fichier avant d'utiliser cette fonction.

Montre la partie de ton code où tu utilises feof() pour que l'on puisse te dire ce qui ne va pas.
0
Linquisiteur
 
Ah salut fiddy, Bon, il s'agit de mon xieme essaie sur mon ancien problème ^^'
J'ai fait plus propre mais à la compile ca va toujours pas.
J'ai pu obtenir un jour de plus pour finir :)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define fichierTexteHexa "hexa1.txt"
#define fichierBinaire "fichier.dat"
#define fichierTexte "fichier.txt"

/**
* Pré:
* @param nb contient un entier initialisé de taille int
* @param carac contient un code ascii d'une lettre ou d'un chiffre
* Post:
* @param nb est inchangé
* @param carac contiendra une valeur décimal
* return: 
* si nb valait 0 on retourne la décimal d'une unité de dizaine d'hexadecimal
* si nb valait un autre nombre on retourne la décimal d'une unité d'hexadecimal
**/
char convert(int nb, unsigned char carac){
	
	if (carac>='0' && carac<='9') carac = carac-'0';
    else carac=carac-55 ;
	
	if (nb==0) carac=carac*16;

 return carac;
}

/**
* Pré:
* @param fichierBin contier l'adresse d'un fichier binaire
* @param fichierHex contient un ficher texte contenant de l'hexadecimal
* Post:
* @param fichierBin contiendra l'hexa traitée
* @param fichierHex est inchangé
**/
void HexaToBin(char * fichierBin, char * fichierHex){
	
	FILE * fichier_Bin;
		//on ouvre le fichier binaire pour y écrire si il y a quelque chose on écrase les info
		if ((fichier_Bin = fopen(fichierBin,"wb"))==NULL) {
        perror("Write "); 
        exit(EXIT_FAILURE);
		}
	
	FILE * fichier_Hex;
		//on ouvre le fichierHex pour lire les info dedans
		if ((fichier_Hex = fopen(fichierHex,"r"))==NULL) {
        perror("Read "); 
        exit(EXIT_FAILURE);
		}
		
		while((!feof(fichier_Hex))){ 
			
			unsigned char lettre[3]={'\n','\n',0};
			
			do{
				 if(lettre[0]=='\n') {
				 lettre[0]=getc(fichier_Hex);
				 lettre[0]=convert(0,lettre[0]);
				 }
				 else {
				 lettre[1]=getc(fichier_Hex);
				 lettre[1]=convert(1,lettre[1]);			
				 }	 
			}while (lettre[0]=='\n' && lettre[1]=='\n');		
			
			lettre[2]=lettre[0]+lettre[1];
			fprintf(fichier_Bin, "%c", lettre[2]) ;
			
        } 
	fclose(fichier_Hex);
	fclose(fichier_Bin);
	}

/**
* Pré:
* @param fichierBin contier l'adresse d'un fichier binaire remplie
* @param fichierTxt contient un ficher texte vide où remplie (mais sera écraser);
* Post:
* @param fichierBin est inchangé
* @param fichierTxt contiendra du texte
**/
void BinToTexte(char * fichierBin, char * fichierTxt){
	
	FILE * fichier_Bin;
		//on ouvre le fichier binaire pour lire le contenu
		if ((fichier_Bin = fopen(fichierBin,"rb"))==NULL) {
        perror("Read "); 
        exit(EXIT_FAILURE);
		}
	
	FILE * fichier_Txt;
		
		//on ouvre le fichierTexte pour y écrire
		if ((fichier_Txt = fopen(fichierTxt,"w"))==NULL) {
        perror("Write "); 
        exit(EXIT_FAILURE);
		}	
	
	 unsigned char lettre;
     while (!feof(fichier_Bin)) {
           lettre=getc(fichier_Bin);
           fprintf(fichier_Txt,"%c", lettre);
           }
		
	fclose(fichier_Txt);
	fclose(fichier_Bin);
	}
	
	
int main (void){

	printf("Travail n°4, en C\n");
	
	/* conversion faux hexadecimal en binaire */
	HexaToBin(fichierBinaire,fichierTexteHexa);
	/* Conversion binaire en texte lisible */
	BinToTexte(fichierBinaire,fichierTexte);
	
return EXIT_SUCCESS;
}


Edit: J'ai modifier un peu le code (unsigned char,..)  fonctionne pas :/

0
fiddy Messages postés 11069 Date d'inscription   Statut Contributeur Dernière intervention   1 846
 
while((!feof(fichier_Hex))){

char ecrire='O';
char lettre[3]={'\n','\n',0};

do{
if(lettre[0]=='\n') {
lettre[0]=getc(fichier_Hex);

Tu utilises mal feof(). feof() n'est pas une condition de fin de fichier. Il faudrait plutôt un truc du genre : if (fgetc(fichier) != EOF) {...} Bien sûr, cela va lire un caractère. Il faut donc stocker fgetc() dans une variable.
Et n'utilise pas getc, mais fgetc(). C'est préférable.
0
Linquisiteur
 
mais je ne vérifierais que le 1er char pas le 2eme
0
fiddy Messages postés 11069 Date d'inscription   Statut Contributeur Dernière intervention   1 846
 
Si tu veux savoir s'il ne reste que deux caractères :
Tu dois lire 3 caractères. Si la dernier vaut EOF, c'est que c'est qu'il y a eu une erreur.
0
Linquisiteur
 
y a t'il moyen d'enregistrer une position d'en un fichier, lire le caractère vérifier si sa vaut eof
et ensuite reprendre position normal ?
0
fiddy Messages postés 11069 Date d'inscription   Statut Contributeur Dernière intervention   1 846
 
Si le fichier n'est pas trop grand, tu peux utiliser ftell() pour récupérer la position du pointeur dans le fichier. Et fseek() pour se repositionner. Mais bon, si tu mémorises les caractères lus dans des variables, tu n'en as pas besoin. Après c'est toi qui vois.
0