Scanf et allocation dynamique

Version imprimable

11/08/2009, 10h57
Saixia

Scanf et allocation dynamique

Bonjour bonjour,
Grande question existentielle...
Je cherche à récupérer une chaîne de caractères sans savoir la longueur de celle-ci. :bug:
Existe t-il un moyen d'utiliser scanf et puis, en fonction de l'entrée, d'allouer une certaine taille de mémoire afin de ne pas devoir gaspiller d'espace en déclarant un méga grand tableau de char avant?
Merci!

Bonjour,

Tel que tu le décris, ça n'existe pas.

En revanche, tu peux tout à fait simuler ce fonctionnement avec un usage de realloc / getchar.

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
char *buf = NULL;
size_t size = 0;
while(1) {
    char *tmp;
    /* récupération du caractère suivant */
    int c = getchar();
    ++size;
    /* on agrandi la chaine */
    tmp = realloc(buf, size);
    if(tmp != NULL) { 
        buf = tmp;
        /* on ajoute le caractère */
        buf[size - 1] = c;
        if(c == '\n' || c == EOF) {
            /* caractère spécial : on le remplace par 0 
               et on sort de la boucle while */
            buf[size - 1] = '\0';
            break;
        }
    } else {
        fprintf(stderr, "error realloc...\n");
        break;
    }
}
 
/* utiliser la chaine ici*/
 
/* ménage */
if(buf != NULL) 
{
    free(buf);
}

/!\ Code pas testé.

J'ai trouvé un exemple avec fgets dans le bouquin de Christophe Blaess (chapitre 10) qui fait à peu près ça. C'est à peu près le code que j'utilise dans mes premiers pas pour le moment. Si ça peut aider.

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
/***********************************************************************\
   exemple_fgets
 
   Programme d'exemple du livre "Developpement systeme en C sous Linux"
   
   (c) 2000,2005 - Christophe Blaess
 
\***********************************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
	char * alloc_fgets (FILE * fp);
 
	int
			main (void)
{
	char * chaine;
 
	while (1) {
		chaine = alloc_fgets(stdin);
		if (chaine == NULL)
			/* Pas assez de mémoire */
			break;
		if ((chaine[0] == '\n') || (chaine[0] == '\0'))
			/* Chaine vide... on quitte */
			break;
		fprintf(stdout, "%d caractères\n", strlen(chaine));
		free(chaine);
	}
	return EXIT_SUCCESS;
}
 
 
	char *
			alloc_fgets (FILE * fp)
{
	char *	retour = NULL;
	char *  a_ecrire = NULL;
	int	taille = 64;
 
	retour = malloc (taille);
	a_ecrire = retour;
 
	while (1) {
		if (fgets (a_ecrire, 64, fp) == NULL)
			break;
		if (strlen (a_ecrire) < 63)
			break;
		/* On se place sur le caractère nul final */
		a_ecrire = a_ecrire + 63; 
		/* Et l'on agrandit également le buffer de 63 caractères */
		taille += 63;
		retour = realloc (retour, taille);
		if (retour == NULL)
			break;
	}
	return (retour);
}

Cela dit (en partant sur cette methode), realloc n'est tres performant, donc si je peux amener une petite amelioration, qui consiste a reallouer par block, ce qui amene un realloc tous les 255 charactere au lieu de chaque caractere (tu peux augmenter le define dependant de la moyenne de la longueur des string que le user va rentrer).

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
 
#define SYZE 255
 
 
char *buf = (char *)malloc(sizeof(char) * SYZE);
size_t size = SYZE;
size_t current_size = 0;
 
while(1) {
    char *tmp;
    /* récupération du caractère suivant */
    int c = getchar();
    ++current_size ;
 
    if(current_size == size)
    {
        size += SIZE;
        /* on agrandi la chaine */
        tmp = realloc(buf, size);
    }
 
    if(tmp != NULL) { 
        buf = tmp;
        /* on ajoute le caractère */
        buf[size - 1] = c;
        if(c == '\n' || c == EOF) {
            /* caractère spécial : on le remplace par 0 
               et on sort de la boucle while */
            buf[size - 1] = '\0';
            break;
        }
    } else {
        fprintf(stderr, "error realloc...\n");
        break;
    }
}
 
/* utiliser la chaine ici*/
 
/* ménage */
if(buf != NULL) 
{
    free(buf);
}

/!\ Code toujours pas testé.

Bon je chipote un peu... ;)

Edit: Grilled avec sensiblement la meme methode... :aie:

11/08/2009, 15h09
Invité(e)

Citation:

Envoyé par wadabush

Cela dit (en partant sur cette methode), realloc n'est tres performant, donc si je peux amener une petite amelioration, qui consiste a reallouer par block, ce qui amene un realloc tous les 255 charactere au lieu de chaque caractere (tu peux augmenter le define dependant de la moyenne de la longueur des string que le user va rentrer).

Oui, realloc n'est pas forcement performant, mais à l'échelle d'un utilisateur qui tape sur son clavier, je ne suis pas sur que cela soit trop perceptible.

Si on veut éviter trop d'appels à realloc et éviter de gâcher de la ram, la meilleur méthode serait à mon avis une allocation par paquet de 256 octets (comme ici) suivit d'une réduction de la taille du buffer à la taille qui va bien.

Au passage, le dernier code posté pose problème : tmp n'est pas initialisé,or on affecte buf à tmp à chaque tour.
11/08/2009, 15h34
vitoubien

Petit retour en arrière sur l'exemple avec fgets que je fournissais, le retour à la ligne est également récupéré dans la chaine résultante.

Alors dans les programmes basiques où j'utilise ce code pour ne récupérer qu'une seule entrée au clavier et non un texte entier en entrée standard, j'ai ajouté avant le return de la fonction la ligne suivante:
retour[strlen(retour) - 1]='\0';
11/08/2009, 15h51
Invité(e)
Citation:
Envoyé par vitoubien

Code:

1 2 3 4 retour = realloc (retour, taille); if (retour == NULL) break; }
Attention, dans ce qui est écrit ci dessus : si realloc échoue, la première chaine est perdue ; on a alors une fuite mémoire.

Bien utiliser realloc().
11/08/2009, 16h19
vitoubien

Citation:

Envoyé par mabu

Attention, dans ce qui est écrit ci dessus : si realloc échoue, la première chaine est perdue ; on a alors une fuite mémoire.

Bien utiliser realloc().

Merci mabu !
Zul m'avait déja pointé ce souci avec realloc mais je n'avais pas bien compris le problème.
Mais quid de la fuite mémoire ? Peux-tu expliciter un peu plus s'il te plait ?
11/08/2009, 17h04
wadabush

La fuite de memoire provient du fait que lorsque tu fais un realloc, tu alloues une nouvelle zone memoire dans laquelle tu copies la zone actuellement pointe par ton pointeur, pour enfin liberer ton pointeur.
Dans le cas ou le realloc fail, il retourne un pointeur NULL. Cela dit, pour eviter de perdre les donnees, l'implementation a ete fete de sorte que realloc ne free le pointeur que tu lui donnes que lorsque la copie a ete effectue avec succes.

Donc si le realloc fail, tu perds ton pointeur, et la memoire n'est pas liberee, d'ou la fuite de memoire ;)
12/08/2009, 19h59
LittleWhite

Le realloc est super dangeureux je trouve. Autant réimplémenter un methode protégé soit même.
Sinon, comme on demande une chaine de caractères ( censé se finir par un \0 ) pourquoi pas faire un strlen ...
Ok je sors ...

Pour realloc(), j'ai tendance à faire un wrapper ainsi:

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
/* Retourne 0 pour succès, -1 pour erreur. */
int realloc_char(char **pp, size_t cElemNewSize)
{
	int ret = -1;
	size_t cbNewSize = cElemNewSize * sizeof **pp;
	char *tmp = realloc(*pp, cbNewSize);
	if(tmp != NULL)
	{
		*pp = tmp;
		ret = 0;
	}
	return ret;
}
 
int realloc_int(int **pp, size_t cElemNewSize)
{
	int ret = -1;
	size_t cbNewSize = cElemNewSize * sizeof **pp;
	int *tmp = realloc(*pp, cbNewSize);
	if(tmp != NULL)
	{
		*pp = tmp;
		ret = 0;
	}
	return ret;
}

Ainsi, en cas d'échec de realloc(), le pointeur est inchangé...