" *Pptr = ( char *)malloc(sizeof(char *)); "

pour rappel c´est
*Pptr = ( char *) malloc ( sizeof(char))

et non pas sizeof(char *) sinon ca alloue la taille d´un pointeur soit 4 octets au lieu d´un. sizeof(qqchose *) = 4 sur nos machines 32 bits.

Plus généralement c´est :

type *ptr;
ptr = ( type *) malloc ( sizeof(type));

Et realloc c´est à éviter car cette fonction est trop souvent buggée ( fuite mémoire). Surtout pour de l´allocation répétée de petit buffer, ce qui est ton cas ! Tu peux vite saturer la mémoire vu windows gère très mal ca.

Le mieux est de passer par de la bufferisation de taille fixée. Tu allous N caractères et tu remplis tant que tu arrives pas à la fin du buffer et tu ralloues d´autant à chaque fois que tu atteints la limite :

N . .. 2*N . .. 3*N etc...

Les allocs c´est lent, très lent, on évite généralement de les utiliser dans une boucle qui demande des perfs en vitesse. C´est pour ca qu´il faut ruser un peu pour en faire le moins possible ( soit tu alloues tout au début et tu gères toi même ensuite, soit tu alloues le moins souvent possible).

non non, son utilisation du malloc est bonne : il fait l´alloc dans la fonction et il modifie le pointeur passe en argument, avec *Pptr un ( char *).

Pour le realloc, il n´y a pas fuites, mais plutot des histoires d´increment de tailles ; tu demandes un petit buffer, il en alloue un gros ( comme ca les realloc suivant sont rapides tant que tu depasses pas la taille preallouee), et il ne realloue vraiment de la mem que lorsque tu depasses ce qui a ete reserve ( un peu comme les vector avec une taille prevue a l´init). Mais du coup, si tu fais plein de realloc sur des petits trucs, y´a des chances que plus de memoire qu´il n´en faut reellement soit reservee..

Dans tous les cas, c´est clair qu´il faut bufferiser ( voire TOUT lire selon la taille des donnees...)

" non non, son utilisation du malloc est bonne : il fait l´alloc dans la fonction et il modifie le pointeur passe en argument, avec *Pptr un ( char *). "

si si relis bien ce qu´il a écrit

je me doute que le but était de modifier le pointeur passé en paramètre mais l´espace alloué n´est pas bon . .. mais dans son cas il alloue 4 octets au lieu d´un pour stocker ses caractères . .

char **qqchose => qqchose = ( char **) malloc ( sizeof(char *));

dans notre cas :

• qqchose = ( char *) malloc ( sizeof(char));

that´s all

lecture en diagonale powaaa ; D

Woua j´ai le crème des programmeurs dans mon topic, trop classe
Merci de m´aider les gars!!
Et je voulais juste savoir ce que vous appelez bufferisation?

Bin c´est d´utiliser des buffer plus grands que ceux dont tu as réellement besoin ( mais pas trop non plus pour ne pas gaspiller inutilement). Quand tu arrives à la limite de ton buffer tu ralloues un peu plus, par ex:

1. define INC_SIZE_ALLOC 256

à l´initialisation :

SizeAllocBuffer = INC_SIZE_ALLOC;
pBuffer = ( char *) malloc ( sizeof(char) * SizeAllocBuffer;

puis ensuite :

NewSize = . ...

if ( NewSize > = SizeAllocBuffer)
{
do
{
SizeAllocBuffer += INC_SIZE_ALLOC;
} while ( NewSize > = SizeAllocBuffer);

pBuffer = ( char *) realloc ( (void *)pBuffer,sizeof(char) * SizeAllocBuffer);
}

/ / tu peux ensuite faire ce que tu as à faire
. ..

ca te permet d´avoir suffisament de mémoire utilisable avec un minimum d´allocations. A toi de régler le define en fonction de tes besoins.

ah oki merci!

Bon j´ai un peu honte, j´ai pas réussi à faire la fonction avec la bufferisation, en fait après étude de ton code j´ai pas trop trop compris...
J´ai fais comme ça, à vous de me dire si c´est propre!
http://wall.cours-info.net/?id=267

Jpense qu´une saisie maxi de 1024 octets c´est suffisant, non?
J´ai oublié de tester les pointeurs, je vais el faire là, mais bon ça ne change rien à la fonction