" enfin dashuhn, perso je préfers faire des fonction de 3 lignes qui gère correctemet la mémoire..."
=> Justemment c´est ce que je fait, et je te reproche de t´être pris la tête pour un problème aussi simple :0

" Ben quand tu t´ammuseras avec des listes chaînées doublement circulaires imbriquées, tu seras bien obligé de gérer correctement la mémoire, parce que tu auras vite fait de la saturer pendant les phases de tests ! "
=> J´ai pas dit le contraire, mais là c´est juste pour lire l´adresse d´un fichier XD

" => Justemment c´est ce que je fait, et je te reproche de t´être pris la tête pour un problème aussi simple :0 "

mais quel que soit la taille de la fonction, il est primordial de ne pas faire de truc comme mathieu en avait fait c´est a dire ou la mémoire disparait à chaque appel.

même si on fonction fait 2 lignes et que pour protégé de ce problème il faille écrire 100 lignes de plus, alors ça vaut le coup.

par contre, ce que tu m´a dit c´est qu´il vaut mieu faire court que économe en mémoire ( en fait ce n´était pas un problème d´être économe, mais de ne pas la jeter par la fenêtre), je pense au contraire qu´il faut toujours privilégier le bon usage de la mémoire que la quantéti de ligne qu´on écrit.

Bin tout le code que tu écriras ira en mémoire à un moment donné... et plus tu feras d´appels plus ton programme sera lent. Dans de nombreux cas en effet vaut mieux bien gérer la mémoire que faire court pour faire court. Mais là je pense que c´est pas la peine de tant s´embêter.

le 39em message je sais pas si vous l´avez lu... revenez à la page précédente svp

euh...
je suis pas super fort, mais ej te passe un bout de code que j´ai écrit pour que tu vois

http://rafb.net/paste/results/H0rNKY12.html

mais comem tu le vois dans le commentaire, je me suis posé la même question que pour toi.
sauf que dans le mien, je croit que en fait la variable se détruit toute seul si j´attend trop longtemps ( se qui n´est pas bon non plus).

sinon, j´ai fait ça grâce au tuto de JYY : http://perso.numericable.fr/~fvirtman/info/tuto/pointeur.cpp en y allant doucement et en se disant tout le temps ce & c´est l´adresse de et * c´est ce qui est pointé par et donc que &(*truc)=truc et *(&)=truc et ça marche.

Mathieun> Si, jlavais vu mais j´ai pas le niveau quoi

http://walljv.free.fr/index.php?to=view&id=42 oui oui je sais...

connaissait pas le walljv.free.fr

par contre il ets vraiment pas beau, et il supporte pas le basic ( ou VB). MECHANT !

/ * et il supporte pas le basic ( ou VB) */

Tant mieux =)

Spa moi qui l´ai dit. Puis pour un développeur...

Bon j´ai trouvé, il "suffisait" de mettre *chaine entre parenthèses

Merci Jarose je vais étudier cette fonction de près

Re-salut tout le monde!
Alors voilà j´ai essayé de faire une fonction scanf qui ne prend en paramètre qu´un pointeur nul, et qui allouie à ce pointeur la taille juste qui correspond à la chaine saisie. Je vous montre ma fonction, qui merde un peu apparemment:

void myscanf(char **Pptr, FILE *flux)
{
*Pptr = ( char *)malloc(sizeof(char *));
int size_s = sizeof(char *);
char current;

if(*Pptr == NULL)
printf("Probleme lors de l´allocation du bloc memoire.\n");
else
{
while((current = fgetc(flux)) ! = ´\n´)
{
size_s += sizeof(char *);
*Pptr = ( char *)realloc(*Pptr, size_s);
strcat(*Pptr, &);
}
}
}

Voilà, alors si qqn pouvait me dire à quel endroit je fais qqch de mal, ça serait très sympa!!

Ah oui, et je voulais aussi savoir comment, avec gcc, je compile par exemple le fichier main.c, qui inclu myscanf.h, qui contient le prototype de myscanf, et est définie dans un fichier myscanf.c, parce que je croyais qu´il suffisait de compiler main.c, mais ça foire, et donc je créé deux objets à partir de main.c et myscanf.c, mais myscanf.h dans l´histoire? il sert à quoi?

Voilà merci à vous pour vos réponses!

Bon, j´ai fait une petite modification:

1. include " myscanf.h"

int myscanf(char **Pptr, FILE *flux)
{
*Pptr = ( char *)malloc(sizeof(char *));
int size_s = sizeof(char *), nbchars = 0;
char current;

if(*Pptr == NULL)
printf("Probleme lors de l´allocation du bloc memoire.\n");
else
{
while((current = fgetc(flux)) ! = ´\n´)
{
size_s += sizeof(char *);
*Pptr = ( char *)realloc(*Pptr, size_s);
if(nbchars == 0)
strcpy(*Pptr, &);
else
strcat(*Pptr, &);
nbchars++;
}
}
return nbchars;
}

Et quand j´entre " Mathieu", ça m´affiche " Ma?t?h?i?e?u?"

où chaque ? est un caractère spécial différent

Voilà j´espère que vous pourrez m´aider!

re-bon, j´ai trouvé une méthode qui me renvoie bien &,Mathieu", mais est-ce que c´est propre? à vous de me le dire...

1. include " myscanf.h"

int myscanf(char **Pptr, FILE *flux)
{
*Pptr = ( char *)malloc(sizeof(char *));
int size_s = sizeof(char *), nbchars = 0;
char current;

if(*Pptr == NULL)
printf("Probleme lors de l´allocation du bloc memoire.\n");
else
{
while((current = fgetc(flux)) ! = ´\n´)
{
size_s += sizeof(char *);
*Pptr = ( char *)realloc(*Pptr, size_s);
if(nbchars == 0)
strcpy(*Pptr, &);
else
strncat(*Pptr, &, sizeof(char));
nbchars++;
}
}
return nbchars;
}

non, ce n´est pas propre, c´est meme ignoble :D

déjà au niveau de la nomenclature, ça prete à confusion, flux pour un FILE * ( on s´attendrait à un istream par exemple avec ce nom), size_s pour un int ( les size_bidule sont souvent utilisés pour des types définis par le compilo ou la plateforme, comme le size_t ou le size_w); Sur la forme, le fait d´allouer la mem dans la fonction n´est pas super intuitif d´un point de vue externe : si qqun utilise cette fonction, va-t-il penser à faire le free ou alors à appeler la fonction qui le fait ; mais surtout, faire des realloc en concatenant des caractère un par un, ça c´est pas bon DU TOUT :/

voilà voilà...

bon pour les noms ça se change, le FILE *flux vient de jarose, et je suis le seul à utiliser cette fonction donc je penserais à utiliser les free.
le size_s, size pour taille, s pour string, la taille de la chaine...

Et pkoi c pas bien les realloc?

j´en conclus que c´est pas si dégueu que ça

Les entrées/sorties standard sont des fichiers, je ne vois pas en quoi ce nom de variable est mal choisi...

Pour ce qui est des realloc à chaque char, il faut vraiment aimer le gruyère, et à trop forte dose, ça devient dégeulasse et on vomi ( :

Pourquoi tu t´obstines à traiter char par char ? C´est lent.

et ben donne moi une solution

justement, ce sont des fichiers, pas des flux...
appelle " ptr" une référence et c´est du pareil au meme.

meme si t´es le seul à utiliser ta fonction, ça n´empeche pas de la penser dans une bonne optique d´utilisation.

oui on devine que size_s est la taille de ta chaine, dans le contexte de la fonction, mais si tu utilisais à coté les types size_t, size_w, size_c et autres, tu verrais que ça prete à confusion. Appelle là string_size ou lenght ou ce que tu veux d´autre ; c´est un peu comme si tu appeler un float " integer".

au lieu de realloquer, lis tout dans un buffer suffisemment grand et parse le texte depuis la memoire.

Ok LGV jvais suivre ton conseil pour size_s
Mais pour le realloc à chaque fois jvois pas comment faire... un buffer de 5 chars ou autre? que je copie régulièrement? ´fin jsais pas