Sinon tu peut faire une boucle avec read qui lit caractere par caractere avec un char buff[1] c'est pas beau mais ca marche
Faut vider le buffer a chaque passage par contre.
int main()
{
int fd;
char buff[1];
fd= open(Fichier, 'r'); verifie le retour open sinon segfaultil renvoie -1 en cas d'erreur
while (read(fd, buff, 1) <= 0)
{
printf("%c", buff[0]);
buff[0] = 0 //vide le char sinon probleme d'ecriture
}
close (fd);
return (0);
}
- Edité par apparence334 3 septembre 2015 à 11:17:04
ATTENTION! ça pique les yeux. (C'est un programme super-calculateur dont les seuls limites est la capacité de ton disque-dur)
Le programme consiste en effet de faire une opération de soustraction, comme de la manière que font les êtres humains, donc en ce moment il me
faudra lire un fichier de la dernière caractère jusqu'au premier caractère pour exécuter le programme et/ du premier au dernier.
En fait je veux reutiliser le caractere renvoyer par le fgetc pour faire des calculs. J'ai remarqué que le caractère est bien là mais il faut qu'elle un
'int' pour que le calcul puisse fonctionné.
Ce que je suis dans ce programme (en guise d'explication et d'aide à la compréhension du système) sont les étapes suivantes.
ETAPE 1= dénombrer le nombre de caractère, dans que contient les deux termes de la soustraction,
ETAPE 2= Définir le mode de déplace du curseur, pour la lecture en inverse des termes contenu dans les fichiers
ETAPE 3= Procéder a l'opération de soustraction (avec d'éventuel stockage de 'retenue' lors des calculs ou ajout de dizaine)
ETAPE 4= Stocker a chaque opération sur les chiffres de même unité (exemple : dizaine, centaine, millième...) constituant les termes, le résultat obtenue dans un fichier nommer 'différence'
ETAPE 5= (à la fin de l'étape 4 nous aurais le résultat de l'opération de soustraction écrit en sens inverse de la lecture, exemple: [150-2 -> 8-4-1])
on inverse le sens de la lecture [150-2->(8-4-1)->(1-4-8)], et on stocke au fur et en mesure dans un fichier nommer 'resultat.txt'.
Remarque: En fait ce programme est conçu pour mener des opérations de soustraction sur des nombres de plusieurs milliers de chiffres, ainsi casser la barrière des limites imposer par les capacités du micro-processeur et de la memoire RAM.En effectuant des petites opérations successives, comme quand on te demande de faire une opération de soustraction entre deux grands nombres écrit sur papier, sans l'aide de calculatrice. Donc à la manière humaine.
NB: nbr= nombre; créer au préalable un fichier pour le plus grand terme de l'opération et un autre sur le plus petit; les opérations sont exclusivement faite sur des entiers naturels; créer un fichier nommer différence et un fichier nomme résultat.
Je ne sais pas si c'est la fonction fgetc qui en est cause du probleme.
Voici le code source du programme: (BONNE LECTURE!)^^
#include <stdio.h>
#include <stdlib.h>
int main()
{
int variableDeParcourFG=0,///Parcourir sur les membres du plus grand terme en valeur absolue
variableDeParcourFP=0,///Parcourir sur les membres du plus petit terme en valeur abslue
variableDeParcourFD=0,///Parcourir sur les membres du fichier difference
chiffreLuDansFG=0,///Chiffre lu dans le fichier du plus grand terme en valeur absolue
chiffreLuDansFP=0,///Chiffre lu dans le fichier du plus petit terme en valeur abslue
dizaine=0,///Dizaine a ajouter en cas de besoin
retenue=0,///Retenue s'il y a eu ajout de dizaine
limitateurDeCalcul=0,///limitateur de la reprise de la boucle de calcul
ardoiseTG[2]={0},///Tableau de calcul
ardoiseTP[2]={0};///Tableau de calcul
///Ouverture des fichiers de stockage des calculs
FILE *ftermeG=fopen("Stock-Div\\termeG.txt","r");
FILE *ftermeP=fopen("Stock-Div\\termeP.txt","r");
FILE *fdifference=fopen("Stock-Div\\difference.txt","r+");
FILE *fresultatSoustraction=fopen("Stock-Div\\resultatSoustraction.txt","w+");
rewind(ftermeG), (ftermeP), (fdifference), (fresultatSoustraction);///Positionnement des curseurs au debut des fichiers
///Variable de calcul
int nbrDeCaractereTG=0,///Nombre de caractere contenue dans le fichier du terme le plus grand
nbrDecaractereTP=0,///Nombre de caractere contenue dans le fichier du terme le plus petit
nbrDeCaractereFD=0,///Nombre de caractere contenue dans le fichier de la diffence
compteurCaractereF=0,///Variable de decompte des caractere contenu dans un fichier
caractereF=0,///Variable a valeur variable de decompte des caractere contenu dans un fichier
difference=0;///Variabme de calcul de difference entre les chiffres de meme unite des termes, le plus grand et le plus petit
///X
do
{
caractereF=fgetc(ftermeG);
compteurCaractereF+=1;
} while (caractereF!=EOF);
nbrDeCaractereTG=compteurCaractereF-1;///Nombre du plus grand terme en valeur absolue
caractereF=0;///Reinitialisation de la valeur du caractere
compteurCaractereF=0; ///Reinitialisation du compteur
do
{
caractereF=fgetc(ftermeP);
compteurCaractereF+=1;
} while (caractereF!=EOF);
nbrDecaractereTP=compteurCaractereF-1;///Nombre du plus petit terme en valeur absolue
caractereF=0;///Reinitialisation de la valeur du caratere
compteurCaractereF=0;///Reinitialisation de la valeur du compteur
///X
///X(1)
fseek(ftermeG,0,SEEK_END);///mis en place du curseur a la fin du plus grand terme dans ftermeG
fseek(ftermeP,0,SEEK_END);///mis en place du curseur a la fin du plus petit terme dans ftermeP
do///Boucle de calcul
{
if (nbrDeCaractereTG>0)///Condition de deplacement du curseur des membres du terme le plus grand
{
variableDeParcourFG-=1; nbrDeCaractereTG-=1;
}
if (nbrDecaractereTP>0)///Condition de deplacement du curseur des membres du terme le plus petit
{
variableDeParcourFP-=1;nbrDecaractereTP-=1;
}
fseek(ftermeG,variableDeParcourFG,SEEK_END);///Positionnement du curseur dans le ftemeG
fseek(ftermeP,variableDeParcourFP,SEEK_END);///Positionnement du curseur dans le ftermeP
chiffreLuDansFG=fgetc(ftermeG);///enregistrement du chiffre lu dans le ftermeG
chiffreLuDansFP=fgetc(ftermeP);///enregistrement du chiffre lu dans le ftermeP
if(retenue==1)///Faire, apres reprise de la boucle, si vraie
{
chiffreLuDansFP+=retenue;
}
if (chiffreLuDansFG<chiffreLuDansFP)///Faire, ajourter une dizaine a chiffreLuDansFG si elle est inferieur a chiffreLuDansFP
{
dizaine=10; chiffreLuDansFG+=dizaine; retenue=1;///Stockage retenue(1)
difference= chiffreLuDansFG-chiffreLuDansFP;///Calcul de difference(1)
fprintf(fdifference,"%d",difference);///Enregistrement du resultat de la difference
}
else if(chiffreLuDansFG>=chiffreLuDansFP)
{
chiffreLuDansFP+=retenue;///Utilisation de la retenue
retenue=0;///Reinitialisation de la retenue a zero une fois utilise
if (chiffreLuDansFG<chiffreLuDansFP)///Faire, ajouter une dizaine a chiffreLuDansFG si elle est inferieur a chiffreLuDansFP apres ajout de la reternue
{
dizaine=10; chiffreLuDansFG+=dizaine; retenue=1;///Stockage retenue(2)
difference=chiffreLuDansFG-chiffreLuDansFP;///calcul de difference(2)
fprintf(fdifference,"%d",difference);///Enregistrement du resultat de la difference(2)
}///(2)
}///(1)
limitateurDeCalcul+=1;
} while (nbrDeCaractereTG!=0);///Sortie de la boucle de calcul, chiffres ecrits en sens inverse de lecture humaine du resultat= sens inv differense
fclose(ftermeG),(ftermeP);///Fermeture des fichiers des termes G et P/car utilisation terminer
///Etape de l'ecriture des chiffres du resultat/ inversement de fdifference
rewind(fdifference);///Positionnement du curseur en debut de texte de difference pour decompte
do///Comptage des caracteres de fdifference
{
caractereF=fgetc(fdifference);
compteurCaractereF+=1;
} while (caractereF!=EOF);
nbrDeCaractereFD=compteurCaractereF-1;///nombre de caractere inscrite dans fdifference
caractereF=0;///Reinitialisation de la variable caractereF
compteurCaractereF=0;///Reinitialisation de la variable compteurCaractereF
fseek(fdifference,-1,SEEK_END);///Positionnement du curseur de fdiffence en fin de texte de difference pour lecture inverse
do///Inversement et ecriture dans resultatSolution
{
fseek(fdifference,variableDeParcourFD,SEEK_CUR);
caractereF=fgetc(fdifference);
fprintf(fresultatSoustraction,"%d",variableDeParcourFD);
variableDeParcourFD-=1;
} while (variableDeParcourFD!=-nbrDeCaractereFD);
return 0;
}
Entre tes deux boucles do{}while tu devrais remettre le curseur à l'origine (rewind).
Attention fseek prend un nombre d'octets en argument, et suivant l'environnement, le nombre de chars n'est pas forcément égal au nombre d'octets. Opte plutôt pour fgetpos et fsetpos pour rétablir le curseur à un certain endroit de manière portable et standard.
[...] car je suis un débutant en fait, j'ai commencé il n'y a pas plus de 3 mois.
Je voudrais convertir la valeur envoyer par fgetc en un 'int'.
[...]
Bonjour,
D'utilisateur un peu expérimenté à débutant :
lit toujours ce que le compilateur te dit. Je ne pense pas qu'il soit resté muet sur les lignes 28 et 124 par exemple …
lit la doc pour savoir comment utiliser les fonctions cela semble ridicule de dire ça mais par exemple pour fgetc tu trouve très rapidement son prototype int fgetc ( FILE * stream ) , et tu remarques vite que la valeur renvoyée par fgetc est un int. Ensuite la manière dont tu pose ta question me fait aussi comprendre que par int tu entends plus la valeur représentée par le caractère (1) que le caractère ('1'). Pour obtenir cela il y a un truc qui fonctionne quand tu es certain d'avoir un caractère compris entre '0' et '9'
int caractere = fgetc(stream);
int valeur = caractere - '0';
First solve the problem. Then, write the code. ~ John Johnson
Attention fseek prend un nombre d'octets en argument, et suivant l'environnement, le nombre de chars n'est pas forcément égal au nombre d'octets. Opte plutôt pour fgetpos et fsetpos pour rétablir le curseur à un certain endroit de manière portable et standard.
Ou ouvrir le fichier (sous windows [linux ? mac ?] ) en binaire, option 'b'
A+
Edgar;
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Attention fseek prend un nombre d'octets en argument, et suivant l'environnement, le nombre de chars n'est pas forcément égal au nombre d'octets. Opte plutôt pour fgetpos et fsetpos pour rétablir le curseur à un certain endroit de manière portable et standard.
Ou ouvrir le fichier (sous windows [linux ? mac ?] ) en binaire, option 'b'
A+
Edgar;
Si le fichier contient du texte non c'est une mauvaise idée.
Par exemple, les retours chariot sous windows sont codés en \r\n si mes souvenirs sont bons, et c'est entre autres choses la raison pour laquelle fgetpos et fsetpos sont requises si l'on veut coder de manière portable/déterministe.
je veux lire un fichier en sens inverse caractere par caractere, et ensuite les ecrires dans un autre fichier.
Ainsi 6-8-5 devient apres transformation 5-8-6;
Pour ce la j'ai mis le curseur derrière le caractere de retour a la ligne('\n') du fichier, puis une fois entree dans la boucle transformation, je deplace le curseur a gauche d'un nombre de fois egale au nombre de lecture deminué de 1.
La barre rouge indique l'emplacement du curseur;
Exemple:
-Position initiale du curseur dans le fichier: ('a' 'm' 'a' 'd' 'o' 'u' '\n'|)
(1) je deplace le curseur de un rang avec l'entrée en boucle
('a' 'm' 'a' 'd' 'o' |'u' '\n')
-Entrée dans la boucle
(3)La position du curseur apres première lecture
('a' 'm' 'a' 'd' 'o' 'u' |'\n')
Le caractere 'u' est lu et puis ecrite dans dans un autre fichier prévu a cet effet
(4) Je repositionne le curseur pour lire le caractere 'o'
('a' 'm' 'a' 'd' |'o' 'u' '\n')
(5)Position du curseur après deuxième lecture
('a' 'm' 'a' 'd' 'o'| 'u' '\n')
Le caractère 'o' est lu et écrite dans mon fichier que j'ai prévu a cet effet
(6)
....
(7)
...
....Ainsi de suite jusqu'à lire tout le texte, et l'écrire dans le fichier prévu à cet effet
(Fin du processus)
à la fin du processus nous aurons dans le fichier que j'ai prévu pour l'écriture le texte suivent
Voici le code que j'ai écrit que j'ai écris pour me faire ça:(excusé pour les fseek^^. Je comence juste de m'habituer a son utilsation. Je rectifierais après)^^
rewind(fdifference);///Positionnement du curseur en debut de texte de difference pour decompte
do///Comptage des caracteres de fdifference
{
caractereF=fgetc(fdifference);
compteurCaractereF+=1;
} while (caractereF!=EOF);
nbrDeCaractereFD=compteurCaractereF-1;///nombre de caractere inscrite dans fdifference
limitateurDeCalcul=compteurCaractereF-1;///reinitialisation du limitateurCalcul
caractereF=0;///Reinitialisation de la variable caractereF
compteurCaractereF=0;///Reinitialisation de la variable compteurCaractereF
rewind(fdifference);
fseek(fdifference,-1,SEEK_END);///Positionnement du curseur de fdiffence en fin de texte de difference pour lecture inverse
fresultatSoustraction=fopen("Stock-Div\\resultatSoustraction.txt","a+");///On reouvre le fichier resultatSoustraction.txt en mode ajout
rewind(fresultatSoustraction); ///Positionnement du curseur en debut du fichier resultatSoustraction.txt
do///Inversement et ecriture dans resultatSolution
{
fseek(fdifference,variableDeParcourFD,SEEK_CUR);
caractereF=fgetc(fdifference);
int valeurFD=0;
valeurFD=caractereF-'0';
fprintf(fresultatSoustraction,"%d",valeurFD);
variableDeParcourFD-=2;
limitateurDeCalcul-=1;
} while (limitateurDeCalcul>0);
fclose(fdifference),(fresultatSoustraction);///Fermeture des fichiers difference et de resultatSoustraction
return 0;
}
Merci,
- Edité par MoMoTrAtRa 5 septembre 2015 à 12:53:08
Avant de poster un message, vérifiez la date du sujet dans lequel vous comptiez intervenir.
Si le dernier message sur le sujet date de plus de deux mois, mieux vaut ne pas répondre. En effet, le déterrage d'un sujet nuit au bon fonctionnement du forum, et l'informatique pouvant grandement changer en quelques mois il n'est donc que rarement pertinent de déterrer un vieux sujet.
Au lieu de déterrer un sujet il est préférable :
soit de contacter directement le membre voulu par messagerie privée en cliquant sur son pseudonyme pour accéder à sa page profil, puis sur le lien "Ecrire un message"
soit de créer un nouveau sujet décrivant votre propre contexte
ne pas répondre à un déterrage et le signaler à la modération
Objectif Zéro Bug - le test logiciel professionnel | L'électronique de zéro | Tableaux & pointeurs | Pointeurs sur fonctions | Lecture/écriture binaire
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Objectif Zéro Bug - le test logiciel professionnel | L'électronique de zéro | Tableaux & pointeurs | Pointeurs sur fonctions | Lecture/écriture binaire