fonction pour lire au clavier

Version imprimable

03/06/2007, 18h14
italiasky

fonction pour lire au clavier

Bonjour,

J'aurais besoin d'aide pour me guider dans cette tâche :
Comment faire une fonction qui lit au clavier ?
Cette fonction retournant une chaîne de caractère lue au clavier.
La longueur de la chaine peut être quelconque.
Et ça doit s’arrêter lorsque l’utilisateur frappe la touche <entrée>.

Bon déjà étant donné que la chaîne de caractère peut être quelconque, cela signifie allocation dynamique je pense non... ?

Mais après je m'y perds, je ne sais pas trop quoi utiliser, fgets, fread... ou d'autres ?

J'ai trouvé et lu plusieurs exemples là dessus sur internet (dont notamment des pages sur http://emmanuel-delahaye.developpez.com/inputs.htm) mais ça coince toujours...

Comment faire pour que l'on puisse taper autant de caractères que l'on veut en une seule fois avant d'appuyer sur la touche <entrée> ? C'est la le problème... si j'utilise un fgets, la taille de ce qu'on peut lire est limitée. Et si on en enchaine plusieurs, ca voudra forcément dire qu'on appuie a chaque fois sur entrée pour finir le fgets non ? donc c'est pas ce qui est recherché..

Merci
++
03/06/2007, 18h34
Franck.H

En C, on a aucun moyen de connaître par avance la taille de la saisie utilisateur, il te faut donc fixer une limite forte et de là, tu peux tranquillement utiliser fgets vu que ton but est de tout récupérer d'un seul coup après appui sur la touche Entrée !
03/06/2007, 18h38
italiasky

Oui mais le but de cet exercice n'est pas de mettre une taille énorme pour que quoi que l'on tape, ca rentrera...
C'est de gérer la mémoire... des trucs comme ca :?
03/06/2007, 18h40
muad'dib

La solution la plus simple, c'est de ne pas faire une allocation dynamique mais d'initialiser un tableau de caractères suffisamment grand pour contenir la majorité des entrées au clavier (en général 512 est suffisant, mais tu peux l'agrandir autant que le permet le tas (je ne connais pas la taille) ).

Sinon si ton utilisateur a l'intention d'écrire un roman je sais pas trop je dois dire... peut-être une fonction du genre kbhit() qui compterait le nombre de touches pressées et sur la détection de la touche entrée faire une allocation dynamique ? Ça fait un peu bricolage...

De toute façon on a toujours plus ou moins une idée de ce que va entrer l'utilisateur.
03/06/2007, 18h52
ITCsoft54

Cette solution est peut être bourrin, mais faire une lecture caractère par caractère, de stocker cela dans un tableau alloué dynamiquement, quand il n'y a plus de place dans le tableau du agrandis celui-ci.

si il tape vraiment quelque chose de très long, passer par un fichier à la place du tableau (cas extrême ou il y aurais pas assez de mémoire ?)
04/06/2007, 09h38
Médinoc
Quelle que soit la solution employée (caractère-par-caractère ou non), il faut utiliser de l'allocation dynamique, et réallouer ta zone mémoire quand "ça dépasse".
- Pour la réallocation, une méthode conseillée est de choisir une nouvelle taille multiple de l'ancienne, avec un multiple inférieur au nombre d'or (pour des raisons dont j'ai oublié les détails). Multiplier par 1.5 satisfait ces critères.
- Si tu ne veux pas faire caractère par caractère, tu peux utiliser la fonction fgets() : C'est en recherchant le \n après chaque saisie que tu sauras si la ligne est terminée ou non...
04/06/2007, 13h44
italiasky

Oui je suis parti sur caractere par caractere avec getchar, mais avec l'histoie du nombre d'or, j'ai pas trop saisi... enfin je posterais ma fonction pour avoir vos avis.

Merci
++
04/06/2007, 14h23
Emmanuel Delahaye

Citation:

Envoyé par italiasky

J'aurais besoin d'aide pour me guider dans cette tâche :
Comment faire une fonction qui lit au clavier ?
Cette fonction retournant une chaîne de caractère lue au clavier.
La longueur de la chaine peut être quelconque.
Et ça doit s’arrêter lorsque l’utilisateur frappe la touche <entrée>.

fgetc(), malloc(), realloc()... Attention, il peut y avoir une limitation système au nombre de caractères lus d'un coup (DOS, 255, Windows 2048 environ etc.).

Citation:

J'ai trouvé et lu plusieurs exemples là dessus sur internet (dont notamment des pages sur http://emmanuel-delahaye.developpez.com/inputs.htm) mais ça coince toujours...

Qu'est-ce qui coince ? Si tu ne montres pas ton code, on ne pas deviner...

Citation:

Comment faire pour que l'on puisse taper autant de caractères que l'on veut en une seule fois avant d'appuyer sur la touche <entrée> ? C'est la le problème... si j'utilise un fgets, la taille de ce qu'on peut lire est limitée. Et si on en enchaine plusieurs, ca voudra forcément dire qu'on appuie a chaque fois sur entrée pour finir le fgets non ? donc c'est pas ce qui est recherché.

Justement, non. Tu devrais lire ceci :

http://emmanuel-delahaye.developpez.com/notes.htm#fgetc
04/06/2007, 14h35
Emmanuel Delahaye

Citation:

Envoyé par muad'dib

Sinon si ton utilisateur a l'intention d'écrire un roman je sais pas trop je dois dire... peut-être une fonction du genre kbhit() qui compterait le nombre de touches pressées et sur la détection de la touche entrée faire une allocation dynamique ? Ça fait un peu bricolage...

Non. Si tu ne sais pas, c'est pas grave, mis évite de raconter n'importe quoi. Des dizaines de gens lisent ces messages et ils n'ont pas envie de lire des bêtises...

Et le but de l'opération est justement qu'on ne sait pas ce qui va être lu (ce n'est pas forcément un 'opérateur', ça peut être un fichier texte de 10 Mo avec un \n voire même aucun).

Voila ce que ca donne :

Code:

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
30
31
32
33
34
 
char* lecture_clavier(unsigned short taille_buffer)
{ 
	char c;
	unsigned long i=0;
	unsigned long j=1;
 
 	if(taille_buffer < 2)
		taille_buffer = 2;
 
	char buffer[taille_buffer];
	char* texte = (char*) malloc(sizeof(buffer));
 
	assert(texte != NULL);
 
	while((c=getchar()) != '\n')
	{
      		buffer[i] = c;
		buffer[++i] = '\0';
 
		if(i == (taille_buffer-1))
		{
			texte = (char*) realloc(texte, sizeof(char)*taille_buffer*++j);
			assert(texte != NULL);
			texte = strcat(texte, buffer);
			i = 0;
		}      		
  	}
 
	if(i != 0)
		texte = strcat(texte, buffer);
 
	return texte;
}

Vous en pensez quoi ?
Des améliorations à apporter ?

Merci
++

06/06/2007, 10h48
Emmanuel Delahaye
Citation:

Envoyé par italiasky

Voila ce que ca donne :
- Ne pas définir de variable de type char sauf absolue nécessité. int suffit dans la majorité des cas. Ca génère moins de code parasite... De plus, ici, on a affaire à getchar() qui retourne un int (comme EOF, par exemple).
- EOF n'est pas testé. Si on lit a partir d'un fichier,
  
  Code:
  
  C:\> monappli <data.txt
  
  c'est la boucle infinie...
- Pas besoin de cast avec malloc().
- Mauvais usage de assert() : http://emmanuel-delahaye.developpez....tes.htm#assert
- utilisation d'un VLA (buffer). Pas portable et surtout absurde. malloc() fait le travail et le fait bien.
- algorithme complexe et difficile à lire
- usage dangereux des opérateurs unaires (++)
- usage naïf de realloc() (en cas d'échec, c'est la fuite mémoire irréparable) : http://emmanuel-delahaye.developpez....es.htm#realloc
- usage abusif de realloc() (à chaque caractère).
- inutile d'affecter le résultat de strcat(). (modifier un pointeur sur une zone allouée, ça fout la trouille !).
- le paramètre de taille ne sert à rien.
La technique a été expliquée. A toi de la mettre en oeuvre.
06/06/2007, 21h55
italiasky

Citation:

Envoyé par Emmanuel Delahaye

[LIST][*]Ne pas définir de variable de type char sauf absolue nécessité. int suffit dans la majorité des cas. Ca génère moins de code parasite... De plus, ici, on a affaire à getchar() qui retourne un int (comme EOF, par exemple).

Oui c'est vrai, mais je pensais que le char était plus logique étant donné qu'on lit un caractère donc ca me paraissait logique de stocké le caractere dans un char.

Citation:

Envoyé par Emmanuel Delahaye

[*]EOF n'est pas testé. Si on lit a partir d'un fichier,

Code:

C:\> monappli <data.txt

c'est la boucle infinie...

Le but de la fonction n'est pas de lire à partir d'un fichier, mais bien de lire une chaine de caractères que l'on tape au clavier.
Mais d'ailleurs j'ai essayé avec un fichier texte, ca fonctionne quand même, comment ca se fait du coup ? Vu que je ne teste pas EOF ?

Citation:

Envoyé par Emmanuel Delahaye

[*]Pas besoin de cast avec malloc().

Bien étant donné que malloc renvoie un void*, et qu'on va stocké dans un char*, je trouve normale de faire un cast (char*) non ? Enfin il me semble que c'est ce qu'on nous a appris...

Citation:

Envoyé par Emmanuel Delahaye

[*]Mauvais usage de assert() : http://emmanuel-delahaye.developpez....tes.htm#assert

De ce coté aussi, on nous a fait employé une macro fonction assert pour vérifier des choses qui sont indispensables à certains moments, sinon le programme s'arrete.

Code:

#define assert(c) { if(!(c)) exit(1); }

Citation:

Envoyé par Emmanuel Delahaye

[*]utilisation d'un VLA (buffer). Pas portable et surtout absurde. malloc() fait le travail et le fait bien.

Là je ne comprends pas trop... le fait d'utiliser le buffer, c'est pour justement ne pas faire un appel à malloc à chaque fois, a chaque caractere par ex.

Citation:

Envoyé par Emmanuel Delahaye

[*]usage dangereux des opérateurs unaires (++)

Pourquoi ? comment ca ?

Citation:

Envoyé par Emmanuel Delahaye

[*]usage naïf de realloc() (en cas d'échec, c'est la fuite mémoire irréparable) : http://emmanuel-delahaye.developpez....es.htm#realloc

Comment ca ? Vous voulez dire qu'au cas ou realloc n'a pa pu aboutir, le reste qu'on avait avant est perdu en fait c'est ca?

Citation:

Envoyé par Emmanuel Delahaye

[*]usage abusif de realloc() (à chaque caractère).

Euh ca je ne suis pas trop d'accord, ca fait un realloc juste si le buffer est plein. donc si on met une taille de buffer de 255, tous les 255 caracteres ca fait un realloc et non a chaque fois...

Citation:

Envoyé par Emmanuel Delahaye

[*]le paramètre de taille ne sert à rien.

Le paramètre que je passe c'est justement pour indiquer la taille de buffer, si on sait que l'utilisateur va tapé seulement quelques mots, on peut prendre une taille de buffer de 50 environ mais si on sait de suite que c'est un long texte qui va etre tapée, on peut mettre un buffer plus grand, afin qu'il n'y ait pas trop de realloc...

Merci de vos explications ;)
Bonne soirée

PS : c'est mieux d'utilsier fgetc a la place de getchar ?
07/06/2007, 01h10
Emmanuel Delahaye

Citation:

Envoyé par italiasky

Le but de la fonction n'est pas de lire à partir d'un fichier, mais bien de lire une chaine de caractères que l'on tape au clavier.
Mais d'ailleurs j'ai essayé avec un fichier texte, ca fonctionne quand même, comment ca se fait du coup ? Vu que je ne teste pas EOF ?

Parce que la ligne est terminée par un \n. Ce n'est pas toujours le cas quand c'est la dernière.

Citation:

Bien étant donné que malloc renvoie un void*, et qu'on va stocké dans un char*, je trouve normale de faire un cast (char*) non ? Enfin il me semble que c'est ce qu'on nous a appris...

On t'a appris de travers. en C, void * est compatible avec tous les types pointeur sur objet. Le cast est donc inutile.

http://emmanuel-delahaye.developpez....tes.htm#malloc

Citation:

De ce coté aussi, on nous a fait employé une macro fonction assert pour vérifier des choses qui sont indispensables à certains moments, sinon le programme s'arrete.

Code:

#define assert(c) { if(!(c)) exit(1); }

Très mauvaise pratique. Redéfinir une macro standard invoque un comportement indéfini.

Citation:

Là je ne comprends pas trop... le fait d'utiliser le buffer, c'est pour justement ne pas faire un appel à malloc à chaque fois, a chaque caractere par ex.

Un buffer avec malloc(), OK, mais pourquoi un VLA de taille fixe ? Il suffit de remplir le buffer extensible (malloc() / realloc()) au fur et à mesure. Il n'y a pas besoin de ce buffer intermédaire et de faire recopies (strcat(). Il suffit de gérer correctement un pointeur ou un indice d'écriture.

Citation:

Comment ca ? Vous voulez dire qu'au cas ou realloc n'a pa pu aboutir, le reste qu'on avait avant est perdu en fait c'est ca?

Oui, comme expliqué dans mon article.

Citation:

Euh ca je ne suis pas trop d'accord, ca fait un realloc juste si le buffer est plein. donc si on met une taille de buffer de 255, tous les 255 caracteres ca fait un realloc et non a chaque fois...

OK, j'avais mal lu. Le bon usage est d'agrandir le buffer d'un facteur compris entre 1.5 et 2 à chaque fois.

Citation:

Le paramètre que je passe c'est justement pour indiquer la taille de buffer, si on sait que l'utilisateur va tapé seulement quelques mots, on peut prendre une taille de buffer de 50 environ mais si on sait de suite que c'est un long texte qui va etre tapée, on peut mettre un buffer plus grand, afin qu'il n'y ait pas trop de realloc...

Une taille raisonnable suffit pour démarrer (16, 32...) ensuite, le système est auto démerdant... Bon, on peut fixer la taille de démarrage, OK. C'est un détail...

Citation:

c'est mieux d'utilsier fgetc a la place de getchar ?

C'est pareil (pour stdin).
07/06/2007, 04h36
dj.motte

Salut,

Je pense que italiasky mélange "saisir avec la console", avec "retaille de la mémoire".

Ce qui plonge nos exégètes dans des bifurcations insoupçonnées.
07/06/2007, 08h41
Emmanuel Delahaye

Citation:

Envoyé par dj.motte

Je pense que italiasky mélange "saisir avec la console", avec "retaille de la mémoire".

Il ne confond pas, il mélange les deux techniques, ce qui est assez courant...

http://emmanuel-delahaye.developpez.com/clib.htm
Module IO
fonctions fget_line() et get_line()
avec l'aide du module FSTR

Bonjour,

J'ai revu ma fonction,
ca donne cela :
Code:

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 30 31 32 33 34 #define verif_ptr(ope) { if(!(ope)) { printf("\n ----- Erreur d'allocation de la mémoire ----- \n"); exit(1); } } char* lecture_clavier(unsigned long taille_buffer) { unsigned long i=0, j=1; char c; char *texte = malloc(sizeof(*texte)*taille_buffer); verif_ptr(texte != NULL); if(taille_buffer < 1) taille_buffer = 5; while((c=getchar()) != '\n') { *(texte+i) = c; i++; if(i%taille_buffer == 0) { texte = realloc(texte, sizeof(*texte)*taille_buffer*++j); verif_ptr(texte != NULL); } } *(texte+i) = '\0'; if(i == 0 || (i+1)%taille_buffer != 0) { texte = realloc(texte, sizeof(*texte)*(i+1)); verif_ptr(texte != NULL); } return texte; }
Je n'ai pas mis "int" mais j'ai laissé char parce que sinon après je ne peux pas afficher ma chaine de caractere avec un %s dans un printf...
C'est vraiment "grave" de stocker dans un char le retour de getchar même si la prototype de cette fonction montre bien qu'elle renvoit un int ?

Et pour le realloc, je ne passe par pas un pointeur intermédiaire parce que apparement realloc libère quand même l'espace pointé par le pointeur qu'on passe en parametre, donc même apres si on veut récupérer le pointeur originale, c'est trop tard non puisque l'espace mémoire pointée aura été libérée ?

Merci
++

Citation:

Envoyé par italiasky

J'ai revu ma fonction,
ca donne cela :

C'est mieux, mais c'est encore un peu compliqué et ça ne traite pas les fichiers (une redirection est toujours possible, surtout en tests...)
Code:

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 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <assert.h> char *lecture_clavier (void) { char *texte = NULL; size_t taille_buffer = 1; texte = malloc (sizeof *texte * taille_buffer); if (texte != NULL) { size_t i = 0; int c; /* verification du tableau */ texte[taille_buffer-1] = 0; while ((c = getchar ()) != '\n' && c != EOF && texte != NULL) { /* verification du tableau */ assert (texte[taille_buffer-1] == 0); texte[i] = c; i++; if (i == taille_buffer) { char *tmp = realloc (texte, sizeof *texte * (taille_buffer * 2)); if (tmp != NULL) { texte = tmp; taille_buffer *= 2; /* verification du tableau */ texte[taille_buffer-1] = 0; } else { free (texte), texte = NULL; } } } if (c != EOF) { texte[i] = 0; /* verification du tableau */ assert (texte[taille_buffer-1] == 0); } else { free (texte), texte = NULL; } } return texte; } int main (void) { if (freopen ("main.c", "r", stdin) != NULL) { char *line; while ((line = lecture_clavier ()) != NULL) { printf ("line = '%s'\n", line); free (line); } } return 0; }
Citation:

Je n'ai pas mis "int" mais j'ai laissé char parce que sinon après je ne peux pas afficher ma chaine de caractere avec un %s dans un printf...

Bah, aucun rapport. Le type retourné par getchar() est int, alors c doit être de type int (pour pouvoir être comparé à EOF). La chaine, par contre est de type tableau de char, car un caractère qui n'est pas EOF entre forcément dans un char.

Code:

texte[i] = c;

est donc correct.

Citation:

C'est vraiment "grave" de stocker dans un char le retour de getchar même si la prototype de cette fonction montre bien qu'elle renvoit un int ?

Oui, comme il vient d'être expliqué.

Citation:

Et pour le realloc, je ne passe par pas un pointeur intermédiaire parce que apparement realloc libère quand même l'espace pointé par le pointeur qu'on passe en parametre, donc même apres si on veut récupérer le pointeur originale, c'est trop tard non puisque l'espace mémoire pointée aura été libérée ?

Non. En cas d'échec, realloc() ne libère rien. Il faut bien faire ce qui a été recommandé.

Bonjour,

J'ai encore changé ma fonction, vous en pensez quoi maintenant ?

Merci
Bonne journée

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
/* Definition des fonctions */
char* lecture_clavier(unsigned long taille_buffer)
{ 
	int c;
	unsigned long i = 0, j = 1;	
	char *texte = malloc(sizeof(*texte)*taille_buffer);
	verif_ptr(texte != NULL);
 
 	if(taille_buffer < 1)
		taille_buffer = 5;
 
	while((c=getchar()) != '\n' && c != EOF)
	{
      		texte[i] = c;
		i++;
 
		if(i%taille_buffer == 0)
		{
			char *tmp = realloc(texte, sizeof(*texte)*taille_buffer*++j);
 
			if(tmp != NULL)
			{
				texte = tmp;
			}
			else
			{
				free(texte);
				return NULL;
			}
		}
  	}
 
	if (c == EOF)
      	{
         	free (texte);
		texte = NULL;
      	}
	else
	{	
		texte[i] = '\0';
		if(i == 0 || (i+1)%taille_buffer != 0)
		{
			char *tmp = realloc(texte, sizeof(*texte)*(i+1));
			if(tmp != NULL)
				texte = tmp;
		}
	}
 
	return texte;  
}

09/06/2007, 11h48
scriptoff

Code:

unsigned long taille_buffer

on utilise size_t pour les tailles en C .

Citation:

Envoyé par italiasky

Tu l'as testée ?

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
line = '#include <stdio.h>'
line = '#♦='
line = '#♦='
line = '#♥='
line = ''
line = '#♥='
line = ''
line = '/♥='
line = 'c♥='
line = '{'
line = '        ☻='
line = '        '
line = '        ☻='
line = '        ☻='
line = ''
line = ' ☻='
line = '        ☻='
line = ''
line = '        ☻='
line = '        {'
line = ' ☺='
line = '        ☺='
line = ''
line = '        '
line = '                {'
line = '        ☺='
line = ''
line = '        ☺='
line = '                        {'
line = '        ☺='
line = '                        }'
line = '        ☺='
line = '                        {'
line = '        '
line = '        ☺='
line = '                        }'
line = '                }'
line = '        }'
line = ''
line = '        ☺='
line = ' '
line = ' '
line = '        ☺='
line = ' ☺='
line = '        '
line = '        {'
line = '        '
line = '        ☺='
line = '                {'
line = '        ☺='
line = '        ☺='
line = '        ☺='
line = '                }'
line = '        }'
line = ''
line = '        ☺='
line = '}'
line = ''
line = ''
line = ' '
line = '{'
line = ' ☺='
line = '   {'
line = ' ☺='
line = ' ☺='
line = ' ☺='
line = ' '
line = ' ☺='
line = ' ☺='
line = '   }'
line = ' '
line = '}'
 
Press ENTER to continue.

Citation:

Code:

1
2
3
4
5
6
char* lecture_clavier(unsigned long taille_buffer)
{ 
	char *texte = malloc(sizeof(*texte)*taille_buffer);
<...> 
 	if(taille_buffer < 1)
		taille_buffer = 5;

Tu ments à ton compilateur. Tu modifies la taille alors que l'allocation a été faite avec la taille originelle... Ca te retomberas dessus un jour où l'autre (perso, j'appelle la fonction avec une taille de 0).

J'ai déjà donné des solutions qui fonctionnent...

Après légère réparation du code :

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
 
#define verif_ptr(ope) { if(!(ope)) { printf("\n ----- Erreur d'allocation de la mémoire ----- \n"); exit(1); } }
 
/* Definition des fonctions */
char *lecture_clavier (unsigned long taille_buffer)
{
   char *texte = NULL;
 
   if (taille_buffer < 1)
      taille_buffer = 5;
   {
      int c;
      unsigned long i = 0, j = 1;
 
      texte = malloc (sizeof (*texte) * taille_buffer);
      verif_ptr (texte != NULL);
 
      /* verification du tableau */
      texte[taille_buffer - 1] = 0;
 
      while ((c = getchar ()) != '\n' && c != EOF)
      {
         /* verification du tableau */
         assert (texte[taille_buffer - 1] == 0);
         texte[i] = c;
         i++;
 
         if (i % taille_buffer == 0)
         {
            char *tmp =
               realloc (texte, sizeof (*texte) * taille_buffer * ++j);
 
            if (tmp != NULL)
            {
               texte = tmp;
               /* verification du tableau */
               texte[taille_buffer - 1] = 0;
            }
            else
            {
               free (texte);
               return NULL;
            }
         }
      }
 
      if (c == EOF)
      {
         free (texte);
         texte = NULL;
      }
      else
      {
         texte[i] = '\0';
         if (i == 0 || (i + 1) % taille_buffer != 0)
         {
            char *tmp = realloc (texte, sizeof (*texte) * (i + 1));
            if (tmp != NULL)
               texte = tmp;
         }
      }
   }
   return texte;
}
 
int main (void)
{
   if (freopen ("main.c", "r", stdin) != NULL)
   {
      char *line;
      while ((line = lecture_clavier (0)) != NULL)
      {
         printf ("line = '%s'\n", line);
         free (line);
      }
   }
   return 0;
}

j'obtiens encore :

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
line = '#inc'
line = '#inc'
line = '#inc'
line = '#inc'
line = ''
line = '#def'
line = ''
line = '/* D'
line = 'char'
line = '{'
line = '   c'
line = ''
line = '        if'
line = '                ta'
line = '{'
line = '        int'
line = '        uns'
line = ''
line = '        tex'
line = '        ver'
line = ''
line = ''
line = '    '
line = '    '
line = ''
line = '        whi'
line = '        {'
line = '    '
line = '    '
line = '    '
line = '                i+'
line = ''
line = '                if'
line = '                {'
line = '                        c'
line = ''
line = '                        i'
line = '                        {'
line = '                                '
line = '    '
line = '    '
line = '                        }'
line = '                        e'
line = '                        {'
line = '                                '
line = '                                '
line = '                        }'
line = '                }'
line = '        }'
line = ''
line = '        if '
line = '    '
line = '    '
line = '                te'
line = '    '
line = '        els'
line = '        {'
line = '                te'
line = '                if'
line = '                {'
line = '                        c'
line = '                        i'
line = '                                '
line = '                }'
line = '        }'
line = '}'
line = '        ret'
line = '}'
line = ''
line = ''
line = ' int'
line = '{'
line = '   i'
line = '   {'
line = '    '
line = '    '
line = '    '
line = '    '
line = '    '
line = '    '
line = '   }'
line = '   r'
line = '}'
 
Press ENTER to continue.

C'est stable, mais en manque des morceaux...

Il a suffit que j'installe correctement de code de debug pour que ça fonctionne :

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
 
#define verif_ptr(ope) { if(!(ope)) { printf("\n ----- Erreur d'allocation de la mémoire ----- \n"); exit(1); } }
 
/* Definition des fonctions */
char *lecture_clavier (unsigned long taille_buffer)
{
   char *texte = NULL;
 
   if (taille_buffer < 1)
      taille_buffer = 5;
   {
      int c;
      unsigned long i = 0, j = 1;
 
      texte = malloc (sizeof (*texte) * taille_buffer + j);
      verif_ptr (texte != NULL);
 
      /* verification du tableau */
      texte[(taille_buffer * j) - 1] = 0;
 
      while ((c = getchar ()) != '\n' && c != EOF)
      {
         /* verification du tableau */
         assert (texte[(taille_buffer * j) - 1] == 0);
         texte[i] = c;
         i++;
 
         if (i % taille_buffer == 0)
         {
            j++;
            char *tmp = realloc (texte, sizeof (*texte) * taille_buffer * j);
 
            if (tmp != NULL)
            {
               texte = tmp;
               /* verification du tableau */
               texte[(taille_buffer * j) - 1] = 0;
            }
            else
            {
               free (texte);
               return NULL;
            }
         }
      }
 
      if (c == EOF)
      {
         free (texte);
         texte = NULL;
      }
      else
      {
         texte[i] = '\0';
         if (i == 0 || (i + 1) % taille_buffer != 0)
         {
            char *tmp = realloc (texte, sizeof (*texte) * (i + 1));
            if (tmp != NULL)
               texte = tmp;
         }
      }
   }
   return texte;
}
 
int main (void)
{
   if (freopen ("main.c", "r", stdin) != NULL)
   {
      char *line;
      while ((line = lecture_clavier (0)) != NULL)
      {
         printf ("line = '%s'\n", line);
         free (line);
      }
   }
   return 0;
}

Oui je l'avais testé et ca fonctionnait, mais c'est vrai que je n'avais pas essayé si on passait 0 comme taille de buffer et que donc oui j'avais oublié de vérifier la taille du parametre avant d'allouer l'espace ;)

Il y a un truc que je ne comprends pas dans votre code, c'est la vérification du tableau.
Pourquoi faire ceci :

Code:

texte[taille_buffer - 1] = 0;

Revoilà ma fonction, quelqu'un peut me dire si cela fonctionne bien chez lui ?
J'ai mis deux exemples, l'un pour tester quand on entre au clavier et l'autre quand on lit un fichier, je ne vois plus d'erreurs, les 2 cas de figures ont l'air de bien fonctionner...

Merci
Bonne journée

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
#include <stdio.h>
#include <stdlib.h>
#define verif_ptr(ope) { if(!(ope)) { printf("\n ----- Erreur d'allocation de la mémoire ----- \n"); exit(1); } } 
 
/* Declarations des fonctions */
char* lecture_clavier(unsigned long);
 
/* Definition des fonctions */
char* lecture_clavier(unsigned long taille_buffer)
{ 
	int c;
	unsigned long i = 0, j = 1;	
	char *texte = NULL;
 
 	if(taille_buffer < 1)
		taille_buffer = 5;
 
	texte = malloc(sizeof(*texte)*taille_buffer);
	verif_ptr(texte != NULL);
 
	while((c=getchar()) != '\n' && c != EOF)
	{
      		texte[i] = c;
		i++;
 
		if(i%taille_buffer == 0)
		{
			char *tmp = realloc(texte, sizeof(*texte)*taille_buffer*++j);
			if(tmp != NULL)
			{
				texte = tmp;
			}
			else
			{
				free(texte);
				return NULL;
			}
		}
  	}
 
	if(c == EOF)
      	{
         	free(texte), texte = NULL;
      	}
	else
	{	
		texte[i] = '\0';
		if(i == 0 || (i+1)%taille_buffer != 0)
		{
			char *tmp = realloc(texte, sizeof(*texte)*(i+1));
			if(tmp != NULL)
				texte = tmp;
		}
	}
 
	return texte;  
}    
 
 
/*************************************/
/*       Programme principal         */
/*************************************/
int main(int argc, char** argv)
{
	/* Exemple 1 : lire au clavier */
	printf("\n----- Exemple 1 : lire au clavier -----\n\n");
	char *machaine = NULL;
 
	printf("Entrez une chaine de caracteres :\n");
 
	machaine = lecture_clavier(0);
 
	printf("\n\nLa chaine tapee est :\n%s\n\n", machaine);
 
	free(machaine);
 
 
	/* Exemple 2 : lire un fichier ligne par ligne*/
	printf("\n----- Exemple 2 : lire un fichier ligne par ligne -----\n\n");
	FILE *monfichier = freopen("lecture_clavier.c", "r", stdin);
 
	if(monfichier != NULL)
   	{
      		char *ligne;
		unsigned short i = 1;
 
     		while((ligne = lecture_clavier(15)) != NULL)
      		{
         		printf ("Ligne %d = '%s'\n", i, ligne);
         		free(ligne);
			i++;
      		}
  	}
 
	fclose(monfichier);
 
  	return 0;
}

09/06/2007, 14h54
Emmanuel Delahaye

Citation:

Envoyé par italiasky

Pourquoi faire ceci :

Code:

texte[taille_buffer - 1] = 0;

Vielle méthode de chacal pour vérifier l'intégrité des chaines (les dépassements de tableau sont une spécialité du C...).

On place un 0 à la position extrême (la plus à droite), et après chaque écriture dans la chaine, on vérifie le 0 est toujours là. Si il n'y est pas, c'est qu'on c'est planté dans le codage des indices, des tailles etc.
09/06/2007, 15h54
italiasky

Lol ok :lol:

Quelqu'un pour essayer vite fait la fonction chez lui ?
Normalement ca devrait être bon ;)

Merci
++