Logo GNT
Actualités Tests & Guides Bons Plans
GTA 6 iPhone 17 Copilot Switch 2 Temu ChatGPT Tesla
OVH Cloud OVH Cloud
Entraide Développement Développement Langage C Tableau de caracteres et pointeurs

Tableau de caracteres et pointeurs

25 réponses
Avatar
bpascal123
Bonjour,
J'apprends le C =E0 partir d'un tutorial en ligne. Je n'arrive pas =E0 un
r=E9sultat pour un exercice dont la solution de l'auteur ne fonctionne
pas non plus. Vous pouvez voir sur l'exercice et la solution que je ne
parviens pas =E0 impl=E9menter sur http://www.ltam.lu/cours-c// ... ex.
9.22.

Voici le code qui ne veut pas tourner alors que =E7a me semble coh=E9rent.
J'y ajoute des fonctions car j'ai d=E9j=E0 parcouru le chapitre fonction
et j'essaie de r=E9soudre les questions de l'allocation dynamique avec
les difficult=E9s du chapitre des fonctions...

/*
Ecrire un programme qui lit 4 mots au clavier (longueur maximale: 10
caract=E8res) et attribue leurs adresses =E0 un tableau de pointeurs pMot.
Copier les mots selon l'ordre lexicographique en une seule 'phrase'
dont l'adresse est affect=E9e =E0 un pointeur pPhr. R=E9server l'espace
n=E9cessaire =E0 la PHRASE avant de copier les mots. Lib=E9rer la m=E9moire
occup=E9e par chaque mot apr=E8s l'avoir copi=E9. Utiliser les fonctions de
<string>.
*/

#include <stdio.h> /* printf fgets */
#include <stdlib.h> /* malloc */
#include <string.h> /* strlen strcpy strcmp strcat */

#define MAXLIG 4 /* nbr de ligne max */
#define MAXLET 10 /* nbr de lettre max */

void ReadPhr(char *fpPhr[], int nmax) ;
void WritePhr(char *fpPhr[], int nmax) ;
void WriteMot(char *fpPhr[], char *fpMot, int nmax) ;
void AlphaPhr(char *fpPhr[], int nmax) ;

int main(void)
{
char *pPhr[MAXLIG] ;
char *pMot =3D 0 ;


ReadPhr(pPhr, MAXLIG) ;
WritePhr(pPhr, MAXLIG) ;
AlphaPhr(pPhr, MAXLIG) ;
WriteMot(pPhr, pMot, MAXLIG) ;

printf("\n\n") ;
return 0 ;
}

void ReadPhr(char *fpPhr[], int nmax)
{
char Intro[MAXLET] ;
int i ;

printf("\n\nEntrez des mots, fin avec [enter] : \n") ;

for ( i =3D 0 ; i < nmax ; i++ )
{
printf("\nEntree %d%s : ", i+1, (i =3D=3D 0) ? "ere" : "eme") ;
fgets(Intro, MAXLET, stdin) ;

*(fpPhr+i) =3D malloc( strlen(Intro)+1) ;

if ( *(fpPhr+i ) )
strcpy( *(fpPhr+i), Intro ) ;
else
{
printf("\nAllocation error\n") ;
exit(-1) ;
}
}
}

void WritePhr(char *fpPhr[], int nmax)
{
int i ;

printf("\n\nAFFICHAGE : \n") ;
for ( i =3D 0 ; i < nmax ; i++ )
printf("\n%s", *(fpPhr+i) ) ;
}

void WriteMot(char *fpPhr[], char *fpMot, int nmax)
{
int i ;
int sz =3D 0 ;

for ( i =3D 0 ; i < nmax ; i++ )
sz +=3D strlen( fpPhr[i] ) ;

printf("\nTaille totale : %d", sz) ;
}

void AlphaPhr( char *fpPhr[], int nmax)
{
void AlphaSwap(char *fpPhr[], int var_i, int var_j) ;
int i, j ;
int pm ;

for ( i =3D 0 ; i < nmax-1 ; i++ )
{
pm =3D i ;
for ( j =3D i+1 ; j < nmax ; j++ )
if ( strcmp( *(fpPhr+pm), *(fpPhr+j) ) > 0 )
pm =3D j ;

AlphaSwap(fpPhr, i, pm) ;
}
}

void AlphaSwap(char *fpPhr[], int var_i, int var_j)
{
char *aide ;

aide =3D fpPhr[var_i] ;
fpPhr[var_i] =3D fpPhr[var_j] ;
fpPhr[var_j] =3D aide ;
}

-0-
Comme je ne comprends pa l'algorithme de tri alphab=E9tique de l'auteur
pour cet exercice, j'ai fait appel au tri par selection du maximum...

Merci,
Pascal
Signaler un problème avec ce contenu

10 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
1 2 3
Avatar
Gabriel Dos Reis
"" writes:

[...]

| Comment décrire stdin?
| Je crois comprendre que c'est l'entrée standard, en mode terminal,
| c'est le clavier,

Ou pas. En général, un processus ne peut pas savoir si son entr ée
standard est relié à un clavier ou autres chose. Il te faut des
extensions, et encore !

| je suppose en mode graphique ou fenêtre, c'est la
| souris...

Non/

| Est-ce que stdin est un fichier sur lequel on peut intervenir?

Qu'entends-tu par intervenir ?

| Est-ce
| que je peux dire, en mode terminal, que stdin est composé des touches
| du clavier que j'ai pressées?

Non. L'entrée standard peut être reliée à autre chose q u'un clavier et
tu ne pourrais pas le savoir de manière portable. Elle peut être une
pipe par exemple.

-- Gaby
Avatar
Gabriel Dos Reis
Tonton Th writes:

| On 08/06/2010 04:27 PM, Gabriel Dos Reis wrote:
|
| > | Comment décrire stdin?
| > | Je crois comprendre que c'est l'entrée standard, en mode termina l,
| > | c'est le clavier,
| >
| > Ou pas. En général, un processus ne peut pas savoir si son en trée
| > standard est relié à un clavier ou autres chose. Il te faut des
| > extensions, et encore !
|
| isatty(int fd) ?

Je présume que la phrase « Il te faut des extensions, et encore ! »
n'est pas passée inaperçue.

-- Gaby
Avatar
Alexandre Bacquart
On 08/05/2010 06:24 o, wrote:
J'ai eu un peu de temps pour étudier et mettre en oeuvre le code que
tu as recommandé. Après quelques modifications, ça fonctionne très
bien. J'ai même été surpris que getchar() soit aussi souple. Je peux
concaténer ou non la saisie par la simple affectation de 'n' ou
'' (dans le code dans A:).



Non, c'est une très mauvaise manière de faire. Ce n'est pas dans les
attributions de ReadUserString() de faire ça. On veut qu'il lise une
chaîne saisie par l'utilisateur. Point.

Si l'utilisateur saisit "pomme" et valide, on veut la chaîne "pomme",
pas la chaîne "pommen".

size_t ReadUserString(char fBuff[], size_t bufsize)
{
char c ;
int i ;
int limit = bufsize - 1 ;

for ( i = 0 ; (c = getchar()) != 'n' ; i++)
if ( i< limit )
fBuff[i] = c ;
else
{
while ( (getchar()) != 'n' )
;
break ;
}
fBuff[i++] = 'n' ; /* A: version 2 : supprimer cette ligne pour
concatener */



Supprime cette ligne, malheureux ! On a fait cette fonction exprès pour
qu'il n'y ait justement pas de 'n' dans les chaînes qu'on récupère, et
toi, tout ce que tu trouves à faire, c'est d'en rajouter un :)

Les 'n', c'est à l'affichage qu'on en rajoutera, mais il n'ont rien à
faire dans les chaînes de l'exercice.

fBuff[i] = '' ;



Et laisse cette ligne tranquille (en plus, avec ta modif., ça déborde
quand on saisit plus que la taille du buffer -> comportement indéfini).

return i ;
}

void WriteMot(char *fPhr[], int nmax)
{
int i ;

printf("nnAffichage : n") ;

for ( i = 0 ; i< MAXLIG ; i++ )



Tu utilisais nmax avant, et c'était très bien, pourquoi changer en
MAXLIG ? c'est peut-être la même valeur, mais l'argument nmax est
justement là pour ça. Alors soit tu supprimes l'argument et utilises
MAXLIG dans la fonction, soit tu laisses l'argument et tu l'utilises
dans la fonction.

printf("%s", *(fPhr+i)) ; /* B: version 2 : changer "%s" par "%s "
pour ajouter un espace pour la concatenation resultant de la
modification en A */



Non, non. L'énoncé ne t'a jamais demandé de rajouter des espaces entre
les mots. Il te demande de trier puis de concaténer les mots saisis et
d'afficher la chaîne finale. Maintenant, si tu veux rajouter des espaces
entre les mots dans la chaîne finale, un bon exercice serait de le faire
entre chaque concaténation.

Par contre, c'est bien ici que tu devrais rajouter 'n' :

printf("%sn", *(fPhr+i)) ;

...puisqu'on veut afficher un mot par ligne à ce stade. Ce n'est pas la
concaténation, c'est le simple affichage des mots pour résumer ce qui a
été saisi. Comme on s'est débarrassés des 'n' qui n'ont rien à faire
dans les mots, on le rajoute ici car pour cet affichage, on veut un
retour à la ligne après chaque mot.

Voici ma version (et WritePhr) :

void WriteMot(char *fpPhr[], int nmax)
{
int i;
printf("nnAffichage :n");
for ( i = 0; i < nmax; i++ )
printf("chaine %d : %sn", i+1, *(fpPhr+i));
}

void WritePhr(char *fpPhr[], char *fpMot, int nmax)
{
int i ;
int sz = nmax ;

for ( i = 0 ; i < nmax ; i++ )
sz += strlen( fpPhr[i] ) ;
sz++;

fpMot = malloc(sz) ;

for ( i = 0 ; i < nmax ; i++ )
strcat( fpMot, fpPhr[i] ) ;

printf("Tri + concaténation : %s", fpMot) ;
}

Comment décrire stdin?



C'est un flux (un tuyau) d'entrée pour ton programme, comme stdout est
un flux de sortie.

Je crois comprendre que c'est l'entrée standard, en mode terminal,
c'est le clavier, je suppose en mode graphique ou fenêtre, c'est la
souris...



L'ennui, c'est que tu vois stdin comme étant essentiellement utilisé
pour lire un périphérique d'entrée utilisateur (comme un clavier ou une
souris). Pourtant rien n'est moins vrai ! On a pas inventé stdin pour
ça. Sur mon système par exemple, il y a des dizaines de programmes C qui
tournent en même temps en permanence. 99% d'entre eux n'ont pas besoin
de lire le clavier et pourtant ils ont tous leur propre flux stdin qui
ne sont connectés à aucun périphérique d'entrée. Certains ne sont
connectés sur rien (le programme n'a pas besoin d'entrée ou il utilise
un autre système de communication), d'autres sont connectés à des flux
stdout appartenant à d'autres programmes (qui eux-mêmes alimentent leur
stdout avec un fichier, ou des événements), etc...

C'est la même chose pour stdout. La plupart du temps, ça n'est pas
connecté sur un terminal.

Il vaut mieux voir le fait d'utiliser stdin pour lire le clavier comme
une *commodité offerte par le système pour les programmes interactifs
(dans le sens interaction avec l'utilisateur) en mode terminal*. Et ça
ne te servira à rien si tu passes au programme graphique interactif, car
à ce niveau, tu utilisera déjà forcément quelques bibliothèques tierces
dont l'une proposera des interfaces clavier et souris plus appropriées
qui n'ont en principe rien à voir avec les mécanismes de flux de C, et
encore moins stdin. Elles seront soit plus abstraites (au point que tu
te ficheras bien de savoir ce que l'utilisateur utilise pour faire de la
saisie), soit plus concrètes (pour un contrôle maximum du périphérique,
genre détecter précisément quand une touche est appuyée, quand elle est
relachée, allumer-éteindre les diodes...). Dans tous les cas, tu seras
bien loin de stdin.

Est-ce que stdin est un fichier sur lequel on peut intervenir?



Qu'entends-tu par "intervenir" ? Ce n'est pas un fichier.

Est-ce
que je peux dire, en mode terminal, que stdin est composé des touches
du clavier que j'ai pressées?



Je préfère te répondre oui, car tu ne fais que des programmes
interactifs dans un terminal et tu les invoques de telle manière que ton
système connecte leur stdin sur le clavier. La réalité, c'est que c'est
un cas à part, pas une généralité.


--
Alex
Avatar
Alexandre Bacquart
On 08/06/2010 10:07 PM, Alexandre Bacquart wrote:
void WritePhr(char *fpPhr[], char *fpMot, int nmax)
{
int i ;
int sz = nmax ;



Tiens, je l'ai zappé celui-là. C'est plutôt :

int sz = 0;

Voici ton programme complet (j'ai changé les noms des variables pour
correspondre à l'énoncé, et j'ai libéré la mémoire allouée) :

/*
Ecrire un programme qui lit 4 mots au clavier (longueur maximale: 10
caractères) et attribue leurs adresses à un tableau de pointeurs pMot.
Copier les mots selon l'ordre lexicographique en une seule 'phrase'
dont l'adresse est affectée à un pointeur pPhr. Réserver l'espace
nécessaire à la PHRASE avant de copier les mots. Libérer la mémoire
occupée par chaque mot après l'avoir copié. Utiliser les fonctions de
<string>.
*/

#include<stdio.h> /* printf fgetsr */
#include<stdlib.h> /* malloc */
#include<string.h> /* strlen strcpy strcmp strcat */

#define MAXLIG 4 /* nbr de ligne max */
#define MAXLET 10 /* nbr de lettre max */

void ReadPhr(char *fpMot[], int nmax) ;
void WritePhr(char *fpMot[], int nmax) ;
void WriteMot(char *fpMot[], int nmax) ;
void AlphaPhr(char *fpMot[], int nmax) ;

int main(void)
{
char *pMot[MAXLIG] ;

ReadPhr(pMot, MAXLIG) ;
WriteMot(pMot, MAXLIG) ;
AlphaPhr(pMot, MAXLIG) ;
WritePhr(pMot, MAXLIG) ;

// libère la mémoire allouée par ReadPhr()
for (size_t i=0; i<sizeof(pMot)/sizeof(*pMot); i++)
free(pMot[i]);

printf("nn") ;
return 0 ;
}

size_t ReadUserString(char *buf, size_t bufSize)
{
char c;
size_t i;
size_t limit = bufSize - 1;
for (i=0; (c = getchar()) != 'n'; i++) {
if (i < limit)
buf[i] = c;
else {
while(getchar() != 'n');
break;
}
}
buf[i] = '';
return i;
}

void ReadPhr(char *fpMot[], int nmax)
{
char Intro[MAXLET+1] ;
int i ;

printf("nnEntrez des mots, fin avec [enter] : n") ;

for ( i = 0 ; i< nmax ; i++ )
{
printf("nEntree %d%s : ", i+1, (i == 0) ? "ere" : "eme") ;

size_t lenIntro = ReadUserString(Intro, sizeof(Intro));

*(fpMot+i) = malloc( lenIntro + 1) ;

if ( *(fpMot+i ) )
strcpy( *(fpMot+i), Intro ) ;
else
{
printf("nAllocation errorn") ;
exit(-1) ;
}
}
}

void WriteMot(char *fpMot[], int nmax)
{
int i ;

printf("nnAffichage :n") ;
for (i = 0 ; i< nmax ; i++)
printf("chaine %d : %sn", i+1, *(fpMot+i) ) ;
}

void WritePhr(char *fpMot[], int nmax)
{
int i ;
int sz = 0;
char *pPhr;

for ( i = 0 ; i < nmax ; i++ )
sz += strlen( fpMot[i] ) ;
sz++;

pPhr = malloc(sz) ;

for ( i = 0 ; i < nmax ; i++ )
strcat( pPhr, fpMot[i] ) ;

printf("Tri + concaténation : %s", pPhr) ;

free(pPhr); // libère la chaîne alloué ici
}

void AlphaPhr( char *fpMot[], int nmax)
{
void AlphaSwap(char *fpMot[], int var_i, int var_j) ;
int i, j ;
int pm ;

for ( i = 0 ; i< nmax-1 ; i++ )
{
pm = i ;
for ( j = i+1 ; j< nmax ; j++ )
if ( strcmp( *(fpMot+pm), *(fpMot+j) )> 0 )
pm = j ;

AlphaSwap(fpMot, i, pm) ;
}
}

void AlphaSwap(char *fpMot[], int var_i, int var_j)
{
char *aide ;

aide = fpMot[var_i] ;
fpMot[var_i] = fpMot[var_j] ;
fpMot[var_j] = aide ;
}


--
Alex
Avatar
bpascal123
Bonjour,

Merci pour ces infos que je trouve importantes pour la saisie en
langage c. Dans d'autres discussions, on avait fait appel à fflush. Je
n'avais pas pris en compte car certainement j'étais concentré sur un
algorithme ou autre...

Dans ce code, j'ai eu du mal à placer free. Il y avait erreur au
moment de la compilation.

Pour l'allocation dynamique, si je comprends bien que free est très
utile pour libérer la mémoire et pour la saisie de caractères, fflush
doit étre présent. Il n'y a pas beaucoup d'infos (j'ai pas beaucoup
cherché) mais je peux lire que fflush vide le buffer. C'est un peu
plus de sécurité alors?

Merci
Pascal
Avatar
espie
In article ,
wrote:
Pour l'allocation dynamique, si je comprends bien que free est très
utile pour libérer la mémoire et pour la saisie de caractères, fflush
doit étre présent. Il n'y a pas beaucoup d'infos (j'ai pas beaucoup
cherché) mais je peux lire que fflush vide le buffer. C'est un peu
plus de sécurité alors?



Non, pas de soucis de securite. Je soupconne que tu fais une confusion
frequente: fflush() s'applique aux flux *en sortie*. Lorsque tu vois un
fflush sur une fonction qui interagit avec le clavier et l'ecran, fflush()
est utilise pour forcer printf() "a afficher" quelque chose.

Par defaut, stdout est en mode "tampon par lignes completes", donc si tu
veux faire un truc tel que:

printf("Entrez un nombre ");
fflush(stdout);
scanf(...);

Ca va mal marcher sans le fflush, vu que printf n'est pas une ligne complete.

[sur certains systemes, ca va fonctionner quand meme. Car il existe un
autre langage, C++, qui lui va lier l'entree standard a la sortie standard,
ce qui fait que toute operation d'entree provoque un flush... et parfois,
ca peut etre remonte jusqu'a la bibliotheque C, ce qui n'est pas interdit.]

De facon assez bizarre, *IL N'Y A PAS* d'equivalent standardise pour l'entree
standard: tu ne peux pas gicler ce que l'utilisateur a tape "simplement" a
l'instant t ou tu fais une entree.

Si on est sur un systeme POSIX (e.g., Unix/Linux, pour simplifier), il y a
des moyens pour manipuler "proprement" l'entree standard (termios), mais ca
devient assez complexe, et il y plein de petits details a gerer. Dans le
monde DOS/Windows, c'est different. Je connais mal et je laisserai quelqu'un
d'autre expliquer tout ca s'il a envie (de ce que j'en sais, c'est assez
primitif, cote getch et getche, et je soupconne que windows emule ce
comportement si on fait des appli texte en cochant la case "terminal").

Pour l'embarque, historiquement, c'est des implementations "freestanding",
donc la bibliotheque standard, dans l'ensemble, est remplacee par autre
chose qui va s'en rapprocher plus ou moins...
Avatar
bpascal123
On Aug 9, 8:54 am, (Marc Espie) wrote:
In article .com>,

wrote:
>Pour l'allocation dynamique, si je comprends bien que free est très
>utile pour libérer la mémoire et pour la saisie de caractères, ffl ush
>doit étre présent. Il n'y a pas beaucoup d'infos (j'ai pas beaucoup
>cherché) mais je peux lire que fflush vide le buffer. C'est un peu
>plus de sécurité alors?

Non, pas de soucis de securite. Je soupconne que tu fais une confusion
frequente: fflush() s'applique aux flux *en sortie*. Lorsque tu vois un
fflush sur une fonction qui interagit avec le clavier et l'ecran, fflush( )
est utilise pour forcer printf() "a afficher" quelque chose.

Par defaut, stdout est en mode "tampon par lignes completes", donc si tu
veux faire un truc tel que:

printf("Entrez un nombre ");
fflush(stdout);
scanf(...);

Ca va mal marcher sans le fflush, vu que printf n'est pas une ligne compl ete.

[sur certains systemes, ca va fonctionner quand meme. Car il existe un
autre langage, C++, qui lui va lier l'entree standard a la sortie standar d,
ce qui fait que toute operation d'entree provoque un flush... et parfois,
ca peut etre remonte jusqu'a la bibliotheque C, ce qui n'est pas interdit .]

De facon assez bizarre, *IL N'Y A PAS* d'equivalent standardise pour l'en tree
standard: tu ne peux pas gicler ce que l'utilisateur a tape "simplement" a
l'instant t ou tu fais une entree.

Si on est sur un systeme POSIX (e.g., Unix/Linux, pour simplifier), il y a
des moyens pour manipuler "proprement" l'entree standard (termios), mais ca
devient assez complexe, et il y plein de petits details a gerer. Dans le
monde DOS/Windows, c'est different. Je connais mal et je laisserai quelqu 'un
d'autre expliquer tout ca s'il a envie (de ce que j'en sais, c'est assez
primitif, cote getch et getche, et je soupconne que windows emule ce
comportement si on fait des appli texte en cochant la case "terminal").

Pour l'embarque, historiquement, c'est des implementations "freestanding" ,
donc la bibliotheque standard, dans l'ensemble, est remplacee par autre
chose qui va s'en rapprocher plus ou moins...



Bonjour,

Comme je te lis, l'exemple que tu donnes avec fflush dans printf et
scanf tombe à pic si je peux dire car dans le code de cette
discussion, j'ai voulu ajouter une saisie par l'utilisateur du nombre
d'enregistrement.

Voici des extraits (le code fait la même chose que celui de cette
discussion même si quelques noms de variables ont changé) :

1 saisie du nom du fichier 2 saisie du nombre d'enregistrements 3
saisie et enregistrement dans le fichier jusqu'arrivé au nombre
d'enregistrement.

int main(void)
{
FILE *P_FILE = NULL ;
char Filename[FILENAMELENGH] ;
char Persname[PERSNAMELENGH] ;
int NbItems ;

printf("nnEnter the name of the file : n") ;
ReadUserString(Filename, FILENAMELENGH) ;

NbItems = ReadNumbOfItems(NUMMAXOFITEMS) ;

P_FILE = fopen(Filename, "w") ;
ReadAndSaveName(P_FILE, Persname, NbItems) ;

fclose(P_FILE) ;

P_FILE = fopen(Filename, "r") ;

DisplayFile(P_FILE) ;

fclose(P_FILE) ;

printf("nn") ;
return 0 ;
}

int ReadNumbOfItems(int nmax)
{
int n ;

printf("Enter the number of records : ") ;

scanf("%d", &n) ;

return n ;
}


Le programme se compile sans erreur ni avertissement.
Lors de l'exécution, arrivé à la question "Enter the number of
records : ", de la fonction ReadNumbOfItems, le nombre est bien lu
mais lorsque la fonction ReadAndSaveName intervient, ça saute le
premier enregistrement, on dirait que c'est 'n' qui traine. Pourtant,
en supprimant la fonction ReadNumbOfItems, il n'y a plus ce problème.
Je pense que c'est scanf qui me pose un problème. J'ai essayé
d'insérer fflush(stdout); entre printf("Enter the numbr of records:)
et scanf("%d",&n) sans succès.

D'après les explications sur fflush, je ne pense pas que le problème
vient de là mais ça me laisse perplexe car je ne m'attendais pas à
rencontrer une difficulté sur la saisie d'un entier avec scanf... Je
pense scanf est spécialement conçu pour ça?

Merci,

Pascal
Avatar
bpascal123
j'ai oublié l'indispensable free dans l'exécution de main. Juste pour
rappel sur la recommandation plus haut, en fin de main il devrait y
avoir :

// libère la mémoire allouée par ReadPhr()
for (size_t i=0; i<sizeof(pMot)/sizeof(*pMot); i++)
free(pMot[i]);

cdt
Avatar
kikonc
a écrit dans le message de groupe de discussion
:

int main(void)
{
FILE *P_FILE = NULL ;
char Filename[FILENAMELENGH] ;
char Persname[PERSNAMELENGH] ;
int NbItems ;

printf("nnEnter the name of the file : n") ;
ReadUserString(Filename, FILENAMELENGH) ;

NbItems = ReadNumbOfItems(NUMMAXOFITEMS) ;

P_FILE = fopen(Filename, "w") ;
ReadAndSaveName(P_FILE, Persname, NbItems) ;

fclose(P_FILE) ;

P_FILE = fopen(Filename, "r") ;

DisplayFile(P_FILE) ;

fclose(P_FILE) ;

printf("nn") ;
return 0 ;
}

int ReadNumbOfItems(int nmax)
{
int n ;

printf("Enter the number of records : ") ;

scanf("%d", &n) ;

return n ;
}


Le programme se compile sans erreur ni avertissement.
Lors de l'exécution, arrivé à la question "Enter the number of
records : ", de la fonction ReadNumbOfItems, le nombre est bien lu
mais lorsque la fonction ReadAndSaveName intervient, ça saute le
premier enregistrement, on dirait que c'est 'n' qui traine



Lors de la lecture d'un fichier il ne peut pas y avoir de 'n' qui traine.


. Pourtant,
en supprimant la fonction ReadNumbOfItems, il n'y a plus ce problème.
Je pense que c'est scanf qui me pose un problème.



Quel problème peut-il bien poser ce scanf, surtout quand, dans la phrase qui
précède, tu dis exactement le contraire : "le nombre est bien lu".

J'ai essayé
d'insérer fflush(stdout); entre printf("Enter the numbr of records:)
et scanf("%d",&n) sans succès.



Normal, dans la mesure que "Enter the numbr of records" apparaissait à
l'écran.


D'après les explications sur fflush, je ne pense pas que le problème
vient de là mais ça me laisse perplexe car je ne m'attendais pas à
rencontrer une difficulté sur la saisie d'un entier avec scanf... Je
pense scanf est spécialement conçu pour ça?



Il n'y a pas de pb dans fflush ou dans scanf, ces fonctions font ce pourquoi
elles sont écrites.
Le problème est l'énorme confusion dans laquelle tu évolues.
Avatar
espie
In article ,
wrote:
int ReadNumbOfItems(int nmax)
{
int n ;

printf("Enter the number of records : ") ;

scanf("%d", &n) ;

return n ;
}



Pas de verif de la valeur de retour de scanf -> pour moi ca suffit,
je ne lis pas plus loin. C'est une perte de temps.
1 2 3