Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans
le code apres avoir ajouté "int **tab"):
Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon
tableau a double entree.
main (int argc, char**argv)
{
int **tab;
do{
if (tab != NULL){
free(tab);
}
tab = (int **)calloc(entier, sizeof(int*));
fonction(autres parametres, &tab);
} while (condition);
if(tab != NULL)
free(tab);
}
int fonction(autres parametres, int **tab)
{
....
for (i = 0; i < taille; i++)
tab[i] = (int *)calloc(taille[i], sizeof(int));
...
... travail sur tab...
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le code apres avoir ajouté "int **tab"): Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon tableau a double entree.
main (int argc, char**argv) { int **tab; Peut-être:
int** tab = NULL; Pour que votre premier free() ne reçoive pas n'importe quoi. Pour le reste, je n'ai pas vraiment regardé en profondeur.
do{ if (tab != NULL){ free(tab); }
tab = (int **)calloc(entier, sizeof(int*));
fonction(autres parametres, &tab); } while (condition);
if(tab != NULL) free(tab); }
int fonction(autres parametres, int **tab) { ....
for (i = 0; i < taille; i++) tab[i] = (int *)calloc(taille[i], sizeof(int)); ... ... travail sur tab...
return 0; }
Merci pour le coup de main.
AZ.
-- Pierre Maurette
Bonjour a tous,
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le
code apres avoir ajouté "int **tab"):
Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon tableau a
double entree.
main (int argc, char**argv)
{
int **tab;
Peut-être:
int** tab = NULL;
Pour que votre premier free() ne reçoive pas n'importe quoi.
Pour le reste, je n'ai pas vraiment regardé en profondeur.
do{
if (tab != NULL){
free(tab);
}
tab = (int **)calloc(entier, sizeof(int*));
fonction(autres parametres, &tab);
} while (condition);
if(tab != NULL)
free(tab);
}
int fonction(autres parametres, int **tab)
{
....
for (i = 0; i < taille; i++)
tab[i] = (int *)calloc(taille[i], sizeof(int));
...
... travail sur tab...
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le code apres avoir ajouté "int **tab"): Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon tableau a double entree.
main (int argc, char**argv) { int **tab; Peut-être:
int** tab = NULL; Pour que votre premier free() ne reçoive pas n'importe quoi. Pour le reste, je n'ai pas vraiment regardé en profondeur.
do{ if (tab != NULL){ free(tab); }
tab = (int **)calloc(entier, sizeof(int*));
fonction(autres parametres, &tab); } while (condition);
if(tab != NULL) free(tab); }
int fonction(autres parametres, int **tab) { ....
for (i = 0; i < taille; i++) tab[i] = (int *)calloc(taille[i], sizeof(int)); ... ... travail sur tab...
return 0; }
Merci pour le coup de main.
AZ.
-- Pierre Maurette
Emmanuel Delahaye
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le code apres avoir ajouté "int **tab"):
On peut donc légitimement se demander si la syntaxe est correcte...
Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon tableau a double entree.
Ben tiens.. C'est sûrement un coup du complot néo-libéralo-judéo-maçonnique...
main (int argc, char**argv) { int **tab; do{ if (tab != NULL){ free(tab);
Déjà ça commence mal. Comme 'tab' n'est pas initialisé, la valeur passée à free() est indéterminée. Le comportement est indéterminé.
}
tab = (int **)calloc(entier, sizeof(int*));
Ok, ça pourrait fonctionner. Le cast est inutile. Les bits à 0 mis par calloc() n'en font pas forcément un tableau de NULL... Ça dépend de l'implémentation. Sujet épuisé ad nauseam, merci de nous croire sur parole ou de lire les archives... calloc() peut echouer...
tab = malloc(entier * sizeof *tab);
fonction(autres parametres, &tab);
&tab ? Je m'attends au pire !
les tableaux alloués dans la fonction ne sont pas libérés...
} while (condition);
Quelle condition ? On ne sait pas...
if(tab != NULL) free(tab); }
int fonction(autres parametres, int **tab)
Vu que le tab de l'appelant est de type int **, son adresse n'est pas de type int **. Le compilateur ne dit rien ?
Retire le & de l'appelant et ça devrait aller.
{ ....
for (i = 0; i < taille; i++) tab[i] = (int *)calloc(taille[i], sizeof(int));
mêmes remarques...
... ... travail sur tab...
les tableaux alloués ici ne sont pas libérés...
return 0; }
-- A+
Emmanuel Delahaye
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans
le code apres avoir ajouté "int **tab"):
On peut donc légitimement se demander si la syntaxe est correcte...
Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon
tableau a double entree.
Ben tiens.. C'est sûrement un coup du complot
néo-libéralo-judéo-maçonnique...
main (int argc, char**argv)
{
int **tab;
do{
if (tab != NULL){
free(tab);
Déjà ça commence mal. Comme 'tab' n'est pas initialisé, la valeur passée
à free() est indéterminée. Le comportement est indéterminé.
}
tab = (int **)calloc(entier, sizeof(int*));
Ok, ça pourrait fonctionner. Le cast est inutile. Les bits à 0 mis par
calloc() n'en font pas forcément un tableau de NULL... Ça dépend de
l'implémentation. Sujet épuisé ad nauseam, merci de nous croire sur
parole ou de lire les archives... calloc() peut echouer...
tab = malloc(entier * sizeof *tab);
fonction(autres parametres, &tab);
&tab ? Je m'attends au pire !
les tableaux alloués dans la fonction ne sont pas libérés...
} while (condition);
Quelle condition ? On ne sait pas...
if(tab != NULL)
free(tab);
}
int fonction(autres parametres, int **tab)
Vu que le tab de l'appelant est de type int **, son adresse n'est pas de
type int **. Le compilateur ne dit rien ?
Retire le & de l'appelant et ça devrait aller.
{
....
for (i = 0; i < taille; i++)
tab[i] = (int *)calloc(taille[i], sizeof(int));
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le code apres avoir ajouté "int **tab"):
On peut donc légitimement se demander si la syntaxe est correcte...
Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon tableau a double entree.
Ben tiens.. C'est sûrement un coup du complot néo-libéralo-judéo-maçonnique...
main (int argc, char**argv) { int **tab; do{ if (tab != NULL){ free(tab);
Déjà ça commence mal. Comme 'tab' n'est pas initialisé, la valeur passée à free() est indéterminée. Le comportement est indéterminé.
}
tab = (int **)calloc(entier, sizeof(int*));
Ok, ça pourrait fonctionner. Le cast est inutile. Les bits à 0 mis par calloc() n'en font pas forcément un tableau de NULL... Ça dépend de l'implémentation. Sujet épuisé ad nauseam, merci de nous croire sur parole ou de lire les archives... calloc() peut echouer...
tab = malloc(entier * sizeof *tab);
fonction(autres parametres, &tab);
&tab ? Je m'attends au pire !
les tableaux alloués dans la fonction ne sont pas libérés...
} while (condition);
Quelle condition ? On ne sait pas...
if(tab != NULL) free(tab); }
int fonction(autres parametres, int **tab)
Vu que le tab de l'appelant est de type int **, son adresse n'est pas de type int **. Le compilateur ne dit rien ?
Retire le & de l'appelant et ça devrait aller.
{ ....
for (i = 0; i < taille; i++) tab[i] = (int *)calloc(taille[i], sizeof(int));
mêmes remarques...
... ... travail sur tab...
les tableaux alloués ici ne sont pas libérés...
return 0; }
-- A+
Emmanuel Delahaye
Zulfukar Arslan
Emmanuel Delahaye wrote:
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le code apres avoir ajouté "int **tab"):
On peut donc légitimement se demander si la syntaxe est correcte...
Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon tableau a double entree.
Ben tiens.. C'est sûrement un coup du complot néo-libéralo-judéo-maçonnique...
main (int argc, char**argv) { int **tab; do{ if (tab != NULL){ free(tab);
Déjà ça commence mal. Comme 'tab' n'est pas initialisé, la valeur passée à free() est indéterminée. Le comportement est indéterminé.
En fait j'ai rajouté un tab = NULL juste avant le "do"
}
tab = (int **)calloc(entier, sizeof(int*));
Ok, ça pourrait fonctionner. Le cast est inutile. Les bits à 0 mis par calloc() n'en font pas forcément un tableau de NULL... Ça dépend de l'implémentation. Sujet épuisé ad nauseam, merci de nous croire sur parole ou de lire les archives... calloc() peut echouer...
tab = malloc(entier * sizeof *tab);
OK. je remplace par un malloc.
fonction(autres parametres, &tab);
&tab ? Je m'attends au pire !
les tableaux alloués dans la fonction ne sont pas libérés...
} while (condition);
Quelle condition ? On ne sait pas...
juste une condition du style entier < 10 et un appel a une fonction qui ne prend pas tab en parametre. donc je pense qu'ici ya pas de probleme.
if(tab != NULL) free(tab); }
int fonction(autres parametres, int **tab)
Vu que le tab de l'appelant est de type int **, son adresse n'est pas de type int **. Le compilateur ne dit rien ?
Si, tu as raison le compilateur me sort un warning, mais le code est si gros et le makefile est si mal ecrit que je ne l'avais pas vu.
Retire le & de l'appelant et ça devrait aller.
Pourquoi? pourtant j'ai l'intention de modifier tab. Il me semblait que si tu voulais modifier une variable, tu devais passer son adresse...
{ ....
for (i = 0; i < taille; i++) tab[i] = (int *)calloc(taille[i], sizeof(int));
mêmes remarques...
... ... travail sur tab...
les tableaux alloués ici ne sont pas libérés...
En fait je libere la memoire seulement dans le main. Je ne m'en occupe
pas dans la fonction. C'est correct?
return 0; }
Emmanuel Delahaye wrote:
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault
dans le code apres avoir ajouté "int **tab"):
On peut donc légitimement se demander si la syntaxe est correcte...
Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon
tableau a double entree.
Ben tiens.. C'est sûrement un coup du complot
néo-libéralo-judéo-maçonnique...
main (int argc, char**argv)
{
int **tab;
do{
if (tab != NULL){
free(tab);
Déjà ça commence mal. Comme 'tab' n'est pas initialisé, la valeur passée
à free() est indéterminée. Le comportement est indéterminé.
En fait j'ai rajouté un tab = NULL juste avant le "do"
}
tab = (int **)calloc(entier, sizeof(int*));
Ok, ça pourrait fonctionner. Le cast est inutile. Les bits à 0 mis par
calloc() n'en font pas forcément un tableau de NULL... Ça dépend de
l'implémentation. Sujet épuisé ad nauseam, merci de nous croire sur
parole ou de lire les archives... calloc() peut echouer...
tab = malloc(entier * sizeof *tab);
OK. je remplace par un malloc.
fonction(autres parametres, &tab);
&tab ? Je m'attends au pire !
les tableaux alloués dans la fonction ne sont pas libérés...
} while (condition);
Quelle condition ? On ne sait pas...
juste une condition du style entier < 10 et un appel a une fonction qui
ne prend pas tab en parametre. donc je pense qu'ici ya pas de probleme.
if(tab != NULL) free(tab); }
int fonction(autres parametres, int **tab)
Vu que le tab de l'appelant est de type int **, son adresse n'est pas de
type int **. Le compilateur ne dit rien ?
Si, tu as raison le compilateur me sort un warning, mais le code est si
gros et le makefile est si mal ecrit que je ne l'avais pas vu.
Retire le & de l'appelant et ça devrait aller.
Pourquoi? pourtant j'ai l'intention de modifier tab. Il me semblait que
si tu voulais modifier une variable, tu devais passer son adresse...
{
....
for (i = 0; i < taille; i++)
tab[i] = (int *)calloc(taille[i], sizeof(int));
mêmes remarques...
...
... travail sur tab...
les tableaux alloués ici ne sont pas libérés...
En fait je libere la memoire seulement dans le main. Je ne m'en occupe
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le code apres avoir ajouté "int **tab"):
On peut donc légitimement se demander si la syntaxe est correcte...
Et evidemment le seg fault n'a l'air d'avoir rien a voir avec mon tableau a double entree.
Ben tiens.. C'est sûrement un coup du complot néo-libéralo-judéo-maçonnique...
main (int argc, char**argv) { int **tab; do{ if (tab != NULL){ free(tab);
Déjà ça commence mal. Comme 'tab' n'est pas initialisé, la valeur passée à free() est indéterminée. Le comportement est indéterminé.
En fait j'ai rajouté un tab = NULL juste avant le "do"
}
tab = (int **)calloc(entier, sizeof(int*));
Ok, ça pourrait fonctionner. Le cast est inutile. Les bits à 0 mis par calloc() n'en font pas forcément un tableau de NULL... Ça dépend de l'implémentation. Sujet épuisé ad nauseam, merci de nous croire sur parole ou de lire les archives... calloc() peut echouer...
tab = malloc(entier * sizeof *tab);
OK. je remplace par un malloc.
fonction(autres parametres, &tab);
&tab ? Je m'attends au pire !
les tableaux alloués dans la fonction ne sont pas libérés...
} while (condition);
Quelle condition ? On ne sait pas...
juste une condition du style entier < 10 et un appel a une fonction qui ne prend pas tab en parametre. donc je pense qu'ici ya pas de probleme.
if(tab != NULL) free(tab); }
int fonction(autres parametres, int **tab)
Vu que le tab de l'appelant est de type int **, son adresse n'est pas de type int **. Le compilateur ne dit rien ?
Si, tu as raison le compilateur me sort un warning, mais le code est si gros et le makefile est si mal ecrit que je ne l'avais pas vu.
Retire le & de l'appelant et ça devrait aller.
Pourquoi? pourtant j'ai l'intention de modifier tab. Il me semblait que si tu voulais modifier une variable, tu devais passer son adresse...
{ ....
for (i = 0; i < taille; i++) tab[i] = (int *)calloc(taille[i], sizeof(int));
mêmes remarques...
... ... travail sur tab...
les tableaux alloués ici ne sont pas libérés...
En fait je libere la memoire seulement dans le main. Je ne m'en occupe
pas dans la fonction. C'est correct?
return 0; }
Harpo
Zulfukar Arslan wrote:
Bonjour a tous,
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le code apres avoir ajouté "int **tab"):
Si tu obtiens un seg fault, c'est que ton programme compile, sa syntaxe est donc correcte.
-- http://patrick.davalan.free.fr/
Zulfukar Arslan wrote:
Bonjour a tous,
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault
dans le code apres avoir ajouté "int **tab"):
Si tu obtiens un seg fault, c'est que ton programme compile, sa syntaxe
est donc correcte.
Est-ce que ce genre de syntaxe est correct (j'obtiens un seg fault dans le code apres avoir ajouté "int **tab"):
Si tu obtiens un seg fault, c'est que ton programme compile, sa syntaxe est donc correcte.
-- http://patrick.davalan.free.fr/
Emmanuel Delahaye
tab = malloc(entier * sizeof *tab);
OK. je remplace par un malloc.
fonction(autres parametres, &tab);
&tab ? Je m'attends au pire !
int fonction(autres parametres, int **tab)
Vu que le tab de l'appelant est de type int **, son adresse n'est pas de type int **. Le compilateur ne dit rien ?
Si, tu as raison le compilateur me sort un warning, mais le code est si gros et le makefile est si mal ecrit que je ne l'avais pas vu.
Retire le & de l'appelant et ça devrait aller.
Pourquoi? pourtant j'ai l'intention de modifier tab. Il me semblait que si tu voulais modifier une variable, tu devais passer son adresse...
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà été correctement initialisé avant l'appel de la fonction, non ?
En fait je libere la memoire seulement dans le main. Je ne m'en occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à ne pas scier la branche sur laquelle tu es assis...).
-- A+
Emmanuel Delahaye
tab = malloc(entier * sizeof *tab);
OK. je remplace par un malloc.
fonction(autres parametres, &tab);
&tab ? Je m'attends au pire !
int fonction(autres parametres, int **tab)
Vu que le tab de l'appelant est de type int **, son adresse n'est
pas de type int **. Le compilateur ne dit rien ?
Si, tu as raison le compilateur me sort un warning, mais le code est
si gros et le makefile est si mal ecrit que je ne l'avais pas vu.
Retire le & de l'appelant et ça devrait aller.
Pourquoi? pourtant j'ai l'intention de modifier tab. Il me semblait
que si tu voulais modifier une variable, tu devais passer son
adresse...
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre
est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà
été correctement initialisé avant l'appel de la fonction, non ?
En fait je libere la memoire seulement dans le main. Je ne m'en
occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à
ne pas scier la branche sur laquelle tu es assis...).
Vu que le tab de l'appelant est de type int **, son adresse n'est pas de type int **. Le compilateur ne dit rien ?
Si, tu as raison le compilateur me sort un warning, mais le code est si gros et le makefile est si mal ecrit que je ne l'avais pas vu.
Retire le & de l'appelant et ça devrait aller.
Pourquoi? pourtant j'ai l'intention de modifier tab. Il me semblait que si tu voulais modifier une variable, tu devais passer son adresse...
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà été correctement initialisé avant l'appel de la fonction, non ?
En fait je libere la memoire seulement dans le main. Je ne m'en occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à ne pas scier la branche sur laquelle tu es assis...).
-- A+
Emmanuel Delahaye
Zulfukar Arslan
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà été correctement initialisé avant l'appel de la fonction, non ?
En fait j'initialise tab dans le main. Je le passe a la fonction et la fonction se charge et de la derniere initilaisation (il s'agit d'un double pointeur), et de le remplir. Donc je le modifie bien puisque je le remplis.
En fait je libere la memoire seulement dans le main. Je ne m'en occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à ne pas scier la branche sur laquelle tu es assis...).
En fait dans la boucle :
tab = NULL; do{ if (tab != NULL){ free(tab); }
tab = (int **)calloc(entier, sizeof(int*));
fonction(autres parametres, tab); } while (condition);
la partie
if (tab != NULL){ free(tab); }
ne me semble pas correcte parce que ce que je voudrais c'est que tant que la condition n'est pas verifiee je recommence l'appel à fonction. Et pour ce faire, j'ai besoin a chaque fois de vider tab et de le reinitialiser.
Dois je plutot ecrire if (tab != NULL){ for (i = 0; i < taille; i++) free(tab[i]); } free(tab); }
puisque fonction m'initialise la derniere partie de tab (qui est un tableau a double entree)?
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre
est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà
été correctement initialisé avant l'appel de la fonction, non ?
En fait j'initialise tab dans le main. Je le passe a la fonction et la
fonction se charge et de la derniere initilaisation (il s'agit d'un
double pointeur), et de le remplir.
Donc je le modifie bien puisque je le remplis.
En fait je libere la memoire seulement dans le main. Je ne m'en
occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à
ne pas scier la branche sur laquelle tu es assis...).
En fait dans la boucle :
tab = NULL;
do{
if (tab != NULL){
free(tab);
}
tab = (int **)calloc(entier, sizeof(int*));
fonction(autres parametres, tab);
} while (condition);
la partie
if (tab != NULL){
free(tab);
}
ne me semble pas correcte parce que ce que je voudrais c'est que tant
que la condition n'est pas verifiee je recommence l'appel à fonction. Et
pour ce faire, j'ai besoin a chaque fois de vider tab et de le
reinitialiser.
Dois je plutot ecrire
if (tab != NULL){
for (i = 0; i < taille; i++)
free(tab[i]);
}
free(tab);
}
puisque fonction m'initialise la derniere partie de tab (qui est un
tableau a double entree)?
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà été correctement initialisé avant l'appel de la fonction, non ?
En fait j'initialise tab dans le main. Je le passe a la fonction et la fonction se charge et de la derniere initilaisation (il s'agit d'un double pointeur), et de le remplir. Donc je le modifie bien puisque je le remplis.
En fait je libere la memoire seulement dans le main. Je ne m'en occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à ne pas scier la branche sur laquelle tu es assis...).
En fait dans la boucle :
tab = NULL; do{ if (tab != NULL){ free(tab); }
tab = (int **)calloc(entier, sizeof(int*));
fonction(autres parametres, tab); } while (condition);
la partie
if (tab != NULL){ free(tab); }
ne me semble pas correcte parce que ce que je voudrais c'est que tant que la condition n'est pas verifiee je recommence l'appel à fonction. Et pour ce faire, j'ai besoin a chaque fois de vider tab et de le reinitialiser.
Dois je plutot ecrire if (tab != NULL){ for (i = 0; i < taille; i++) free(tab[i]); } free(tab); }
puisque fonction m'initialise la derniere partie de tab (qui est un tableau a double entree)?
Zulfukar Arslan
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà été correctement initialisé avant l'appel de la fonction, non ?
J'ai retiré le & et ca ne marche toujours pas.
En fait je libere la memoire seulement dans le main. Je ne m'en occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à ne pas scier la branche sur laquelle tu es assis...).
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre
est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà
été correctement initialisé avant l'appel de la fonction, non ?
J'ai retiré le & et ca ne marche toujours pas.
En fait je libere la memoire seulement dans le main. Je ne m'en
occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à
ne pas scier la branche sur laquelle tu es assis...).
Si tu veux modifier le tab, comme déjà expliqué, le type du paramètre est incorrect. Mais pourquoi diable veux-tu modifier le tab ? Il a déjà été correctement initialisé avant l'appel de la fonction, non ?
J'ai retiré le & et ca ne marche toujours pas.
En fait je libere la memoire seulement dans le main. Je ne m'en occupe pas dans la fonction. C'est correct?
Du moment que tout ce qui a été alloué est libéré, oui (et attention à ne pas scier la branche sur laquelle tu es assis...).
Zulfukar Arslan
Voila c'est corrigé. Il suffisait de terminer la liberation memoire (apres free(tab)) par tab = NULL. Et la ca marche.
A bientot et merci.
Voila c'est corrigé. Il suffisait de terminer la liberation memoire
(apres free(tab)) par tab = NULL. Et la ca marche.
