grr.. encore un pb d'alloc :s (realloc & strncat)

Version imprimable

Voir 40 message(s) de cette discussion en une page

Voici une fonction qui doit mettre en mémoire un fichier texte dans un char * :

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
 
#define fichierConf "config.php"
int main(int argc, char *argv[], char **envp){
    char *confSrc="yep";    
    loadTextFile(fichierConf, &confSrc);
    printf("%s",confSrc);
    free(confSrc);    
    exit(0);
}
 
 
void loadTextFile(char *name, char **stockage){
    #define tailleBuffer 512
    char buffer[tailleBuffer];
    FILE *file;
    int NbLu;
    int taille=strlen(*stockage);
    printf("TAille initiale : %i\n",taille);
 
    if((file=fopen(name, "r")) == NULL){
	printf("Ouverture impossible du fichier %s :s\n",name);	
	exit(1);
    }
 
    while( (NbLu=fread(buffer, 1, tailleBuffer, file)) != 0){
	taille+=NbLu;
	*stockage=(char *) realloc(*stockage,taille+1);
	strncat(*stockage,buffer,NbLu);
	(*stockage)[taille-1]=0x0;
    }
    fclose(file);
}

Quand mon char * de stockage (confSrc) est initialisé à 0x0, le prog marche mais j'ai un caractère bizarre qui s'insère au tout début. Par contre, quand il est déjà initialisé, le prog plante :(

05/09/2006, 05h18
prof Tournesol

Salut ramislebob,
Je pense que ton problème vient plus de l'utilisation hasardeuse de la chaîne "yep" affectées directement au char * confSrc, que d'une défaillance des fonctions d'allocations (bien que je te déconseille de continuer avec realloc).
Mon prof d'algo-prog m'a un jour expliqué que les chaînes litérales "..." étaient stockées quelque part en mémoire dans un endroit qu'il ne vaut mieux pas manipuler.
Je te conseille d'essayer l'affectation suivante :

Citation:

char *confSrc = (char *) malloc(4);
strcpy(confSrc, "yep");
confSrc[4] = 0x0;

.
Je crois que ton affaire ne s'en portera pas plus mal...
05/09/2006, 09h58
DaZumba

On ne peut re-allouer qu'un pointeur NULL ou associe a un espace memoire retourne par malloc(). Rien d'autre. Et ton code est tres moche...

En general, on re-alloue en doublant la taille allouee (car c'est une fonction potentiellement couteuse). Il faut donc maintenir un compteur du nombre de caracteres lus, a comparer avec l'espace memoire disponible. Egalement, puisque tu lis un fichier texte, fgets() est plus appropriee que fread().
05/09/2006, 10h09
Médinoc

Si j'ai bien compris une discussion précédente, il est déconseillé de multiplier la taille alloué par un nombre supérieur au nombre d'or (2 > 1.62), la raison s'expliquant par une suite de Fibonacci...

Compte tenu de ce critère, il est courant qu'on multiplie la taille par 1.5 (mais on pourrais aussi la multiplier par la racine de deux si l'on voulait)...
05/09/2006, 10h13
homeostasie
Code bien compliqué qui implique des erreurs...
Code:

1 2 3 4 5 6 7 loadTextFile(fichierConf, &confSrc); void loadTextFile(char *name, char **stockage)// Quel est l'intérêt? { ... }
Je ferais ainsi:
Code:

1 2 3 4 5 6 loadTextFile(fichierConf, confSrc); void loadTextFile(char *name, char *stockage) { ... }
Pour l'allocation dynamique:

Citation:

Je te conseille d'essayer l'affectation suivante :
Citation:
char *confSrc = (char *) malloc(4);

Plutot cela:
Code:

1 2 3 4 #define NbCaract 4 char *confSrc = malloc(NbCaract * sizeof(*confSrc));
Code:

*stockage=(char *) realloc(*stockage,taille+1);

Stocker l'adresse sur laquelle il faut pointer dans le contenu de l'adresse pointée par stockage, c'est pas logique....
05/09/2006, 10h21
DaZumba
Citation:

Envoyé par Médinoc

Si j'ai bien compris une discussion précédente, il est déconseillé de multiplier la taille alloué par un nombre supérieur au nombre d'or (2 > 1.62), la raison s'expliquant par une suite de Fibonacci...

Encore des mathematiciens desoeuvres :)

J'avais aussi oublie d'ecrire que realloc() ne s'utilise pas comme cela. En effet, si elle echoue en renvoyant NULL, l'espace alloue precedemment n'est pas libere. Si on ecrase la valeur du pointeur par NULL, alors cet espace est perdu (fuite memoire).
Il faut utiliser un pointeur temporaire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 type *ptr = realloc(old_ptr, new_size); if (ptr != NULL) { old_ptr = ptr; ... } else { free(old_ptr); /* error */ }
Evidemment, au lieu de faire le free(old_ptr), on peut mettre en place un mecanisme plus sophistique (reclamer de la memoire non utilisee et retenter le realloc() par exemple).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdlib.h>
 
int MyRealloc(void ** ppData, size_t newSize)
{
	void *pTmp = realloc(*ppData, newSize);
	if(pTmp == NULL)
		return -1;
	else
	{
		*ppData = pTmp;
		return 0;
	}
}

Et ça s'appelle ainsi (là hélas, je crois bien que le cast est obligatoire)

Code:

1
2
3
4
if( MyRealloc((void**) &buf, new_size) )
{
	/* erreur */
}

05/09/2006, 12h26
ramislebob
Citation:
Envoyé par prof Tournesol

Je pense que ton problème vient plus de l'utilisation hasardeuse de la chaîne "yep" affectées directement au char * confSrc, que d'une défaillance des fonctions d'allocations (bien que je te déconseille de continuer avec realloc).

Code:

1 2 3 4 char *confSrc = (char *) malloc(4); strcpy(confSrc, "yep"); confSrc[4] = 0x0;
Effectivement, bien vu ;)
ça résout le pb ^^

Citation:

Envoyé par DaZumba

On ne peut re-allouer qu'un pointeur NULL ou associe a un espace memoire retourne par malloc(). Rien d'autre. Et ton code est tres moche...

Quand j'initialise mon char* à NULL, plantage :s
en revanche un :
Code:

1 2 3 char *confSrc = (char *) malloc(1); confSrc[0]=0x0;
permet une initialisation à vide.
bref, realloc semble ne s'appliquer QUE à un espace mémoire alloué par malloc.

Citation:

Envoyé par DaZumba

Et ton code est tres moche...

pourkoi :s ? je vois pas trop comment faire autrement, plus propre...
j'attends des suggestions ;)

Citation:

Envoyé par DaZumba

puisque tu lis un fichier texte, fgets() est plus appropriee que fread().

je vais regarder la doc de fgets, y a longtemps que je l'ai pas utilisé.

Citation:

Envoyé par homeostasie

loadTextFile(fichierConf, confSrc);

void loadTextFile(char *name, char *stockage)
{
...
}

ben il me semble que ça ne va pas. Pour modifier un char * dans une fonction il faut lui passer en param un pointeur sur ce char *... dites me si je me trompe mais je ne pense pas.

Citation:

Envoyé par homeostasie

*stockage=(char *) realloc(*stockage,taille+1);

Stocker l'adresse sur laquelle il faut pointer dans le contenu de l'adresse pointée par stockage, c'est pas logique....

Pas compris ce que tu veux dire. *stockage est un char *, l'adresse du début de mon string. stockage est un pointeur sur mon string.

Citation:

Envoyé par DaZumba

J'avais aussi oublie d'ecrire que realloc() ne s'utilise pas comme cela. En effet, si elle echoue en renvoyant NULL, l'espace alloue precedemment n'est pas libere. Si on ecrase la valeur du pointeur par NULL, alors cet espace est perdu (fuite memoire).

Merci de m'avoir rajouter la remarque, cé vrai que j'avais totalement zappé ce point plutot important.. :s

Citation:

Envoyé par DaZumba

on peut mettre en place un mecanisme plus sophistique (reclamer de la memoire non utilisee et retenter le realloc() par exemple).

qu'est ce que tu entends par "réclamer de la mémoire" ? est il possible de connaitre la mem disponnible ?
Citation:
Envoyé par Médinoc

Et ça s'appelle ainsi (là hélas, je crois bien que le cast est obligatoire)

Code:

1 2 3 4 5 if( MyRealloc((void**) &buf, new_size) ) { /* erreur */ }
cé koi un cast ?
le transtipage en (void **) est il vraiment nécessaire ? ça compile très bien sans.
Rq : j'ai récup ta fonction, merci.

Bon.. voilà mes remarques / questions :p
encore merci à tous ;)
05/09/2006, 12h49
DaZumba
Citation:

Envoyé par ramislebob

bref, realloc semble ne s'appliquer QUE à un espace mémoire alloué par malloc.

D'apres la norme du langage C, un appel realloc(NULL, size) est equivalent a malloc(size) et un appel realloc(ptr, 0) est equivalent a free(ptr).
De plus, c'est quoi 0x0 ? Autant utiliser NULL ou 0, au moins on est sur que le compilateur mettre bien le pointeur a l'adresse invalide correspondant a NULL, qui n'est pas forcement 0x0.

Citation:

Envoyé par ramislebob

pourkoi :s ? je vois pas trop comment faire autrement, plus propre...
j'attends des suggestions ;)

D'abord, la programmation C n'est pas un concours de compression de donnees. Une ligne comme
Code:

1 2 if((file=fopen(name, "r")) == NULL){
est plus agreablement ecrite ainsi:
Code:

1 2 3 4 5 6 file = fopen(name, "r"); if (file == NULL) { ... }
Non ?
Ensuite, je te conseille d'ecrire les erreurs sur stderr (qui peut etre redirige independamment de stdout, ce qui est pratique).
Donc
Code:

1 2 printf("Ouverture impossible du fichier %s.\n",name);
devient
Code:

1 2 fprintf(stderr, "Ouverture impossible du fichier %s.\n",name);
Le exit(1) en cas d'echec est trop violent. Il faut remonter un code d'erreur a main(), qui est la seule fonction terminant le programme. Le prototype de ta fonction devient alors
Code:

1 2 int loadTextFile(char *name, char **stockage)
et main() teste le retour de cette fonction (et peut ainsi return EXIT_SUCCESS ou EXIT_FAILURE au systeme d'exploitation). Remarque egalement que dans le bout de code que tu donnes, le prototype de loadTextFile() est inconnu par main(). Ton compilateur doit signaler cet oubli. Il manque egalement les en-tetes stdio.h et stdlib.h. Comme tu castes realloc() [ce qui est mal en C], cela signifie que realloc() est supposee retourner un int, non un void *, ce qui cause probablement tes problemes de segmentation fault.

Citation:

Envoyé par ramislebob

qu'est ce que tu entends par "réclamer de la mémoire" ? est il possible de connaitre la mem disponnible ?

Non, c'est a toi de creer tout un mecanisme de garbage collection (comptage de reference par exemple). C'est ce que j'appelle un 'mecanisme plus sophistique'. Pour l'instant, contente toi de faire un free() si realloc() echoue [ce que je fais la plupart du temps, en fait!].
05/09/2006, 12h59
homeostasie

Citation:

Citation:
homeostasie a écrit :

...
char *confSrc = malloc(NbCaract * sizeof(*confSrc));
loadTextFile(fichierConf, confSrc);
...

void loadTextFile(char *name, char *stockage)
{
...
}

ben il me semble que ça ne va pas. Pour modifier un char * dans une fonction il faut lui passer en param un pointeur sur ce char *...

En effet, c'est cela qui est fait! ;)
En gros, on pourrait dire que ca correspond à cela:

Code:

char *stockage = confSrc;

Ce qui signifie que stockage reçoit l'adresse de "confSrc" et donc pointe sur le début de ta chaîne de caractère "confSrc".

Citation:

Pas compris ce que tu veux dire. *stockage est un char *, l'adresse du début de mon string. stockage est un pointeur sur mon string.

Ben non, *stockage est un char et non un char*! stockage est l'adresse de début de ton string et *stockage représente le premier caractère de ta chaîne.
05/09/2006, 13h15
homeostasie
Citation:

est il possible de connaitre la mem disponnible ?

Oui ca l'est en utilisant des variables et/ou fonctions spécifiques au noyau. Le mieux c'est d'avoir accès aux fichiers sources.
Sinon il faut redéfinir ses propres fonctions (malloc, calloc, realloc, free) pour connaître la mémoire totale utilisée,libérée et donc restante. Mais dans ton cas, je ne pense pas que cela a de l'importance.

Juste comme cela:
Code:

1 2 3 strncat(*stockage,buffer,NbLu); (*stockage)[taille-1]=0x0;
Pas besoin de mettre à 0 après l'utilisation de strncat.

Citation:

strncat() recopie au plus 'len' caractères de la chaîne 'sce' à la fin de 'dest', puis y ajoute un caractère '\0'.

;)

Citation:
Envoyé par ramislebob
Voici une fonction qui doit mettre en mémoire un fichier texte dans un char * :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int main(int argc, char *argv[], char **envp){ char *confSrc="yep"; loadTextFile(fichierConf, &confSrc); <...> } void loadTextFile(char *name, char **stockage){ <...> *stockage=(char *) realloc(*stockage,taille+1); <...> }
Quand mon char * de stockage (confSrc) est initialisé à 0x0, le prog marche mais j'ai un caractère bizarre qui s'insère au tout début. Par contre, quand il est déjà initialisé, le prog plante :(
On ne peut pas réallouer une chaine fixe. Il faut commencer par NULL ou malloc().

La taille de la chaine allouée n'est pas connue. Il faut la gérée séparément. Je recommande une structure du type
Code:

1 2 3 4 5 6 struct dyn_str { size_t size; char *s; };

05/09/2006, 13h47
Emmanuel Delahaye
Citation:
Envoyé par prof Tournesol

Je te conseille d'essayer l'affectation suivante :

Code:

1 2 3 4 char *confSrc = (char *) malloc(4); strcpy(confSrc, "yep"); confSrc[4] = 0x0;
- Le cast est inutile.
- Il faut vérifier si malloc() a réussi avant d'utiliser le bloc alloué.
- confSrc[4] n'existe pas. (comportement indéfini)
- De plus, il y a déjà un 0 en confSrc[3]...
05/09/2006, 13h58
Emmanuel Delahaye
Citation:

Envoyé par DaZumba

De plus, c'est quoi 0x0 ? Autant utiliser NULL ou 0, au moins on est sur que le compilateur mettre bien le pointeur a l'adresse invalide correspondant a NULL, qui n'est pas forcement 0x0.

Hum, non. Dans un contexte pointeur, char *p = 0 et char *p = NULL sont strictement équivallents. L'usage de NULL est purement documentaire. (comme '\0' vs 0 pour les fins de chaines).

Ce qu'on a pas le droit de faire, c'est
Code:

1 2 3 4 char *p; memset (&p, 0, sizeof p);
en croyant faire p = 0. Ce n'est pas portable, car p = 0 ne veut pas forcément dire 'mettre tous les bits à 0'.

Avec char p = 0, comme on est dans un contexte 'pointeur', le compilateur sait ce qu'il a à faire. (Si ça se trouve, il va écrire 0x80000000 dans le pointeur, qui sait...)
05/09/2006, 14h13
DaZumba

Citation:

Envoyé par Emmanuel Delahaye

Hum, non. Dans un contexte pointeur, char *p = 0 et char *p = NULL sont strictement équivallents. L'usage de NULL est purement documentaire. (comme '\0' vs 0 pour les fins de chaines).

Oui, mon interrogation etait plus sur '0x0 est-il egal a 0 et est-il interprete par le compilateur comme NULL en contexte pointeur ?'. Je ne sais pas cela...
05/09/2006, 14h17
homeostasie

Citation:

La taille de la chaine allouée n'est pas connue. Il faut la gérée séparément. Je recommande une structure du type

Oui, d'ailleurs voici ce que dit la fac:
http://c.developpez.com/faq/c/?page=...taille_allouee
05/09/2006, 14h22
homeostasie

Citation:

Oui, mon interrogation etait plus sur '0x0 est-il egal a 0 et est-il interprete par le compilateur comme NULL en contexte pointeur ?'. Je ne sais pas cela...

Je dirais que ca soit en hexa ou en décimal, zéro vaut zéro! ;) Puis je me dis qu'à la base, c'est du binaire de toute façon.
Mais peut être que je me trompe....
05/09/2006, 14h44
DaZumba

Citation:

Envoyé par homeostasie

Je dirais que ca soit en hexa ou en décimal, zéro vaut zéro!

Oui, ma question est idiote.
05/09/2006, 14h46
gege2061

Citation:

Envoyé par DaZumba

Oui, mon interrogation etait plus sur '0x0 est-il egal a 0 et est-il interprete par le compilateur comme NULL en contexte pointeur ?'. Je ne sais pas cela...

En c99, NULL ou 0 correspondent à une adresse invalide, en C90 je ne crois pas.
05/09/2006, 14h53
Emmanuel Delahaye

Citation:

Envoyé par DaZumba

Oui, mon interrogation etait plus sur '0x0 est-il egal a 0 et est-il interprete par le compilateur comme NULL en contexte pointeur ?'. Je ne sais pas cela...

N'importe quelle expression constante valant 0 est équivallente à NULL dans un contexte pointeur.

Voir 40 message(s) de cette discussion en une page