jmen fous que mon code soit bourrin, au moins je le comprends celui là

Et puis merci dnob jcommence à comprendre, jvais ptet utiliser ta méthode, bien qu´elle soit très peu différente de la mienne dans mon cas.

oui, mais c´est important de désallouer la mémoire que tu aloue sinon, si ton programme debvient gros et que tu fait souvent appel à cette fonction, ça peut devenir catastrophique ( et puis c´est une bonne habitude à prendre).

La règle numéro un du bon programeur : la mémoire tu ne gachera pas.

Bon... si tu me prends par les sentiments à parler comme Maître Yoda...
Jvais suivre ton conseil

Si je me souviens bien, la grosse différence entre le C et le Pascal en ce qui concerne la gestion de la mémoire, c´est qu´en Pascal, quand tu ferme le programme, la mémoire utilisée est totalement libérée, ce qui n´est pas le cas avec un programme en C.

Enfin, pas totalement !

si si, windows ( c´est indépendant du langage) fait ça très bien et libère toute le mémoire.

mais ce n´est pas propre et puis il faut espérer ne pas dépasser la mémoire pendant l´exécution du programme.

Je parlais en dehors de Windows, bien sûr.
Mes souvenirs de Turbo Pascal et mes notions de C datent de 92/93, et le Turbo C 2.0 ne tournait pas sous Windows, c´était une Appli Ms-Dos.

ah oui, avec d´autre OS, j´en sais rien, je te fait confiance.

c´est un réflexe de windowsien que de ne penser qu´a windows en premier lieu pour ce genre de question ( même si je suppose que mathieu bosse sous windows).

En fait, c´est Windows qui se charge de libérer la mémoire en fin de programme, mais s´il compile son prog sous dos, linux ou autre OS, il risque effectivement de laisser des trucs dans la mémoire.

" La règle numéro un du bon programeur : la mémoire tu ne gachera pas."
=> Tu préfères faire des fonctions de 50 lignes pour un problème qui peut être réglé en trois ?

" il risque effectivement de laisser des trucs dans la mémoire."
=> Non, pas pour les Unix en tout cas.

" Tu préfères faire des fonctions de 50 lignes pour un problème qui peut être réglé en trois ? "

je comprend pas le rapport ?
pourquoi économiser la mémoire implique-t-il de faire des grosses fonctions ?

Bien gérer la mémoire ( allouer et libérer la mémoire uniquement quand on en a besoin) nécessite un peu de code.

Bin dans ce cas là je préfère mon code ( même si il devrait prévoir la taille de la mémoire, mais sais plus faire d´allocation dynamique) qui est quand même tout petit ( et getchar() est généralement la plus rapide).

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 !

enfin dashuhn, perso je préfers faire des fonction de 3 lignes qui gère correctemet la mémoire...

Autant faire le boulot correctement plutôt que d´être obligé d´y revenir parce que ça a causé un bug. Comme on dit, " il vaux mieux prévenir que guérir ! " .

Et puis c´est une question d´habitude, je n´aime pas bâcler le boulot !

ben maintenant y a plus rien qui fonctionne:

void my_scanf(char *chaine)
{
int i = 0, j;
char *buffer = ( char *)calloc(sizeof ( char*), 500);
while((buffer[i] = getchar()) ! = ´\n´)
++i;
chaine = ( char *)calloc(sizeof ( char*), i+1);
for(j = 0; j < i; chaine[j++] = *buffer++);
free(buffer);
}

----------------------------------------
char *pathf = NULL;
my_scanf(pathf);

quand je fais printf("%s", pathf); ça affiche ( null)

normal,

il faut que tu déclare :

void my_scanf(char **chaine)

c´est donc un pointeur vers un pointeur, ce qui te permet de modifer le pointeur !

mais la bonne méthode serait :

void my_scanf(char *chaine, int *Size)

le pointeur est DEJA aloué avant d´appeler la fonction, il est alloué pour size octets et à la fin, Size contient le nombre d´octet qui ont été écrit dans la variable.

s´il n´ya pas assez d´octet dans chaine alors c´est pas grave la fonction donne ceux qu´elle peut et tant pis pour le reste.

warning, possible loss of data

jvais déjà essayer avec le pointeur de pointeur, mais j´arrive pas à m´imaginer ce que je vais devoir traiter, et surtout comment je vais le traiter:

Je passe en paramètre le pointeur d´un pointeur. Donc dans mon programme je définis un char *pathf qui est le pointeur qui va pointer vers la chaine, donc je l´initialise à NULL, et je définis un char **ppath, qui pointe vers le pointeur pathf. Donc je l´initialise à?... &?
Ensuite, quand je vais devoir allouer la mémoire pour la chaine, je fais *chaine ( donc chaine est le pointeur qui pointe vers pathf, d´où *chaine = pathf) donc *chaine = ( char *(??? pas sûr??))calloc(sizeof(char *), i+1);

Éclairez moi svp, parce que j´ai un peu de mal à comprendre ce casse-tête!