Discussion :

[Ash95]

Bonjour tout le monde,

J'ai vraiment besoin de votre aide!!!

Je dois faire un programme qui réponds à cette consigne

Chaque chaine doit être stockée dans une zone de mémoire allouée exprès pour la chaine.
Si la chaine est de longueur n, la zone allouée sera de longueur n+1 et pas plus. On ne tolère plus le gaspillage de mémoire.

Améliorez votre programme pour permettre la saisie d'un nombre illimité de chaine. Lorsque l'utilisateur aura saisi la dernière, il devra frapper ctrl-d, vous pouvez utiliser la fonction feof (????? ) pour sortir de la boucle de saisie. Le tableau des adresses des chaines saisies sera ralloué par tranche de 10 en utilisant la fonction realloc.

Voilà c'est la deuxième question de mon exercice.... La première je l'ai faites et elle fonctionne, il fallait que la longueur de la chaine n'excède pas 127 caractères (j'ai choisi de mettre 7 caractères ). Si l'utilisateur essaie de saisir une chaine plus longue, la chaine sera tronquee. Il fallait utiliser la fonction fgets en mettant stdin comme dernier argument.

Je n'attend pas des réponses complète (ça serait trop facile...) mais juste des explications qui m'aideront à y voir plus claire! D'avance merci beaucoup !!!

[Sve@r]

Bonjour

Je n'attend pas des réponses complète (ça serait trop facile...)

De toute façon ici ce n'est pas notre politique...

vous pouvez utiliser la fonction feof (????? )

T'as raison d'être étonné. Je ne sais pas quel est le débile qui a écrit ce conseil car il est complètement à l'ouest. feof ne sert pas à détecter une fin de saisie mais à indiquer, une fois que la saisie ne se fait plus, si la fin est due à une fin normale ou à une fin anormale (erreur disque, etc...).

La fin de saisie se détecte via la fonction de saisie elle-même qui renvoie une valeur particulière quand le flux se termine. Donc typiquement, ce sera un truc du style

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
while (fonction_de_saisie() != valeur_particuliere)
{
    faire traitement
}

Ensuite, si tu veux utiliser feof, alors ce sera de cette façon

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
while (fonction_de_saisie() != valeur_particuliere)
{
    faire traitement
}
 
if feof(stdin)
{
    fin_de_saisie_normale
}
else
{
    fin_de_saisie_due_a_une_erreur
}

Ensuite pour le realloc, c'est tout simple: tu définis 3 éléments

• ton tableau lui-même
• sa taille réellement allouée (qui variera dans ton cas de 10 en 10)
• l'indice de remplissage

Et tout ça initialisé à 0

Ensuite, tu fais ta boucle de saisie. Mais (dans la boucle), avant de remplir le tableau, tu regardes si l'indice de remplissage a atteint la taillle allouée (ce qui est obligatoirement le cas lors de la première itération puisque ces deux valeurs sont à 0). Si c'est le cas, alors tu augmentes la taille allouée de 10 puis tu fais un realloc de la taille allouée. Et si le tableau est à NULL (ce qui est aussi le cas à la première itération), alors realloc se comporte comme un malloc.
Et ensuite, une fois cette étape d'allocation terminée, dans tous les cas, tu remplis la case du tableau située à l'indice de remplissage puis tu augmentes celui-ci de 1.
Tu peux dérouler cet algo à la main, tu verras que jamais les éléments stockés ne dépassent le tableau qui les contient...

[sambia39]

Bonjour

Bonjour tout le monde,
J'ai vraiment besoin de votre aide!!!
Je dois faire un programme qui réponds à cette consigne
.......
Améliorez votre programme pour permettre la saisie d'un nombre illimité de chaine. Lorsque l'utilisateur aura saisi la dernière, il devra frapper ctrl-d, vous pouvez utiliser la fonction feof (????? ) pour sortir de la boucle de saisie. Le tableau des adresses des chaines saisies sera ralloué par tranche de 10 en utilisant la fonction realloc.
Je n'attend pas des réponses complète (ça serait trop facile...) mais juste des explications qui m'aideront à y voir plus claire! D'avance merci beaucoup !!!

Avez-vous bien lu et compris l'énoncer du sujet et ce que l'on vous demande de faire ?

Bonjour

De toute façon ici ce n'est pas notre politique...
T'as raison d'être étonné. Je ne sais pas quel est le débile qui a écrit ce conseil car il est complètement à l'ouest. feof ne sert pas à détecter une fin de saisie mais à indiquer, une fois que la saisie ne se fait plus, si la fin est due à une fin normale ou à une fin anormale (erreur disque, etc...).

La fin de saisie se détecte via la fonction de saisie elle-même qui renvoie une valeur particulière quand le flux se termine. Donc typiquement, ce sera un truc du style

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
while (fonction_de_saisie() != valeur_particuliere)
{
    faire traitement
}

Ensuite, si tu veux utiliser feof, alors ce sera de cette façon

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
while (fonction_de_saisie() != valeur_particuliere)
{
    faire traitement
}
 
if feof(stdin)
{
    fin_de_saisie_normale
}
else
{
    fin_de_saisie_due_a_une_erreur
}

Je ne pense pas que l'enseignent soit complètement à l'ouest je dirais même qu'il est un très bon professeur et qu'il vous donne de très bon exercice au final il est vrai qu'il a une vision de vous comme étant des futures professionnelles.

Personnellement je trouve que c'est t'un très bon exercice et bien conçu de façon à exploiter de manière astucieuse et intelligente les entrées sorties.
Ce que vous avez énoncé est correcte pour la fonction

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

feof( FILE *iop )

elle renvoie bien une valeur non nulle si la fin de fichier est atteint. Il fait mieux encore en vous mettons sur la piste (il est généreux) en précisant que l'utilisateur doit taper CTRL-D pour fermer le flot en clair la fonction de saisie qui est tout simplement bloquante car lors de la lecture du clavier ( du stdin ) il n'y a à pas de fin de fichier donc on se retrouve dans une lecture constante ( lecture bloquante) ce qui permet à l'utilisateur de taper des caractères comme bon lui semble et la seule façon d'arrêter cette saisie est la combinaison des touches CTRL-D (Unix) ou CTRL-Z (Windows)
Ce qui donne au final le code source ci-dessous qui pourrait répondre a ces attentes et qui est à adapter, optimiser et corriger.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define SIZE	10
 
int main( void ){
 
	int er_write = 0;
	char *p = (char*)calloc( SIZE, sizeof(char) );
	if( (NULL) == p ){
		fprintf( stderr, "(%d)\n Erreur Allocation\n>>\t%s\n",
				errno, strerror(errno) );
		return( EXIT_FAILURE );
	}
 
	do{
		p = fgets( p, SIZE, stdin ); 	/* Lecture du fichier 			*/
		er_write = feof( stdin );		/* Controle  fin de fichier 	*/
		fprintf( stdout, "%s", p ); 	/* Print du résultat			*/
	}while( !er_write );				/* Fin de boucle CTRL-D/CTRL-Z	*/
 
	free( p );
	p = NULL;
 
	return( EXIT_SUCCESS );
}

à bientôt

[Sve@r]

Ce que vous avez énoncé est correcte pour la fonction

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

feof( FILE *iop )

elle renvoie bien une valeur non nulle si la fin de fichier est atteint.

Ce qui justement ne permet pas de détecter qu'on est sur le dernier enregistrement. Si le fichier contient 3 enregistrements, il faudra lire 4 fois pour que feof() soit activé.

Il fait mieux encore en vous mettons sur la piste (il est généreux) en précisant que l'utilisateur doit taper CTRL-D pour fermer le flot en clair la fonction de saisie qui est tout simplement bloquante car lors de la lecture du clavier ( du stdin ) il n'y a à pas de fin de fichier donc on se retrouve dans une lecture constante ( lecture bloquante) ce qui permet à l'utilisateur de taper des caractères comme bon lui semble et la seule façon d'arrêter cette saisie est la combinaison des touches CTRL-D (Unix) ou CTRL-Z (Windows)

Oui mais les fonctions de lecture savent interpréter ce "CTRL-D" et dans ce cas, renvoient la valeur attribuée à l'info "je ne lis plus rien, j'ai terminé".

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
	do{
		p = fgets( p, SIZE, stdin ); 	/* Lecture du fichier 			*/
		er_write = feof( stdin );		/* Controle  fin de fichier 	*/
		fprintf( stdout, "%s", p ); 	/* Print du résultat			*/
	}while( !er_write );				/* Fin de boucle CTRL-D/CTRL-Z	*/
	free(p);

Et que se passe-t-il si stdin est vide à la première lecture ??? fgets ne lit rien, indique qu'il n'y a rien à lire mais ce renseignement n'est pas traité et on tente d'afficher quand-même p. Dans ce cas précis ça va quand-même car afficher NULL fonctionne mais si on effectue un traitement plus complexe, c'est le crash !!!

PS: je ne sais pas si fgets() fait un malloc pour qu'il y ait ce free derrière. Mais s'il en fait un, alors autant d'itération dans la boucle, autant de malloc non libérés. Fuite mémoire en plus...

Une première correction serait alors de vérifier feof() avant de traiter. Et d'utiliser un tableau destinataire des infos lues au lieu de ce malloc non controlé (surtout qu'on a la taille connue !!!)

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
	char p[SIZE];
	do{
		fgets( p, SIZE, stdin ); 	/* Lecture du fichier 			*/
		er_write = feof( stdin );		/* Controle  fin de fichier 	*/
                if (er_write) break;		/* Si lecture inutile sortie de boucle */
		fprintf( stdout, "%s", p ); 	/* Print du résultat			*/
	}while( !er_write );				/* Fin de boucle CTRL-D/CTRL-Z	*/

Mais on teste alors 2 fois la même chose, ce qui est contre productif. Accessoirement, appeler une variable "er_write" pour indiquer une erreur de "lecture"... On va alors supprimer le second test et cette variable au nom si mal choisi...

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
	while (1) {
		fgets( p, SIZE, stdin ); 	/* Lecture du fichier 			*/
                if (feof( stdin )) break;		/* Si lecture inutile sortie de boucle */
		fprintf( stdout, "%s", p ); 	/* Print du résultat			*/
	}	/* Fin de boucle CTRL-D/CTRL-Z	*/

Alors là ça devient ok et robuste. Mais bon, outre le fait que certains puristes n'aiment pas l'utilisation d'interruptions impromptues, c'est quand-même dommage d''utiliser une seconde fonction pour redemander une info que la première avait déjà donnée. Autant alors rester simple et tester directement le retour de la lecture elle-même. Après-tout, si cette info existe, c'est peut-être pour quelque chose...

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
	while (fgets( p, SIZE, stdin ) != NULL) 	/* Lecture du fichier 			*/
		fprintf( stdout, "%s", p ); 	/* Print du résultat			*/
	}	/* Fin de boucle CTRL-D/CTRL-Z	*/

Et voilà - Fonctionne pareil mais avec moitié-moins de code et sans cette variable si mal nommée et qui s'avéra finalement si inutile...

[sambia39]

(+1)Très bonne analyse & correction

PS: je ne sais pas si fgets() fait un malloc pour qu'il y ait ce free derrière. Mais s'il en fait un, alors autant d'itération dans la boucle, autant de malloc non libérés. Fuite mémoire en plus...

Peut-être confus de mon côté, mais il me semble bien que la fonction fgets n'alloue pas de mémoire mais stocke les caractères dans le buffer qui doit être une zone mémoire préalablement allouée soit un tableau de caractère ou une allocation dynamique.
et le free vient du

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
char *p = (char*)calloc( SIZE, sizeof(char) );
	if( (NULL) == p ){
		fprintf( stderr, "(%d)\n Erreur Allocation\n>>\t%s\n",
				errno, strerror(errno) );
		return( EXIT_FAILURE );
	}

J'avoue avoir une mauvaise analyse sur ce coup.
Merci pour tes remarques et à bientôt.

[Sve@r]

Peut-être confus de mon côté, mais il me semble bien que la fonction fgets n'alloue pas de mémoire mais stocke les caractères dans le buffer qui doit être une zone mémoire préalablement allouée soit un tableau de caractère ou une allocation dynamique.
et le free vient du

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

char *p = (char*)calloc( SIZE, sizeof(char) );

Ok, j'avais pas fait attention. Mais dans ce cas, surtout ne pas perdre p donc ne pas écrire ensuite p=fgets(...). C'est lui qui m'a fait tilter sans que je lise ce qu'il y avait au dessus...