Discussion :

[Stéphoune]

Bonjour à tous,

J'ai un problème avec une fonction que j'ai développé. La fonction prend un int * et un int en paramètre et crée un tableau de la taille précisée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void mk_tab(int *t,int n) {
 
     t = (int *)malloc(n*sizeof(int));
 
     int i;
 
     for (i=0; i<n; i++) t[i]=i;
}

Sur le même principe, j'ai une fonction d'affichage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void visu_tab(int *t, int n) {
 
     int i;
 
     printf("{ ");
 
     for (i=0; i<n; i++)
         {printf("%d ",t[i]);}
 
     printf("}\n");
 
}

Dans le main(), je procède aux appels ci-dessous :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int *t;
 
int i,j;
 
for (j=1; j<10; j++) {
    mk_tab(t,j);
    visu_tab(t,j);
}

Je m'attends à avoir en sortie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
{ 0 }
{ 0 1 }
{ 0 1 2 }
{ 0 1 2 3 }
{ 0 1 2 3 4 }
{ 0 1 2 3 4 5 }
{ 0 1 2 3 4 5 6 }
{ 0 1 2 3 4 5 6 7 }
{ 0 1 2 3 4 5 6 7 8 }

Or, j'ai des valeurs complètement farfelues :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
{ -1 }
{ -1 2088999640 }
{ -1 2088999640 2088857728 }
{ -1 2088999640 2088857728 0 }
{ -1 2088999640 2088857728 0 0 }
{ -1 2088999640 2088857728 0 0 0 }
{ -1 2088999640 2088857728 0 0 0 4198944 }
{ -1 2088999640 2088857728 0 0 0 4198944 0 }
{ -1 2088999640 2088857728 0 0 0 4198944 0 2020893505 }

A première vue, ça pue le débordement mémoire à plein nez, mais je n'arrive pas à en trouver l'explication. Quelqu'un a une idée?

PS : Je développe sous Dev-C++

[Stéphoune]

Une petite précision qui n'a pas beaucoup d'importance mais qui mérite d'être soulignée : Ce bout de code n'est qu'un cas d'étude que j'ai reproduit pour débugger une partie d'un projet un peu plus gros.

Celui-ci consiste à élaborer une représentation par matrice d'adjacence d'un graphe non orienté. J'y développe des fonctions de parcours de noeuds (en largeur d'abord et en profondeur d'abord).

Et pour ce faire, j'ai besoin d'une fonction qui retourne pour un noeud donné n (indice dans la matrice), un tableau contenant les indices des voisins de n (indices i de la matrice pour lesquels m[n][i] est égal à 1.

Le tableau retourné doit donc être de taille variable, d'où la petite fonction ci-dessus développée.

[Pouet_forever]

Le problème majeur vient du fait que tu envoies le pointeur de ton tableau à ta fonction.
Un pointeur pointe vers une adresse donc il à une adresse 'à lui' et une adresse distante. Ce que tu fais c'est modifier l'adresse distante, alors qu'il faudrait que tu modifies l'adresse du pointeur.
Il faut donc passer par un pointeur de pointeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void mk_tab(int **t,int n) {
     int i;
 
     (*t) = malloc(n*sizeof(int));
     for (i=0; i<n; i++)
          (*t)[i]=i;
}

Et dans ta fonction main il faut que tu utilises '&t' quand tu appelles ta fonction.

De plus tu appelles ta fonction mk_tab à chaque appel de boucle, il ne faut pas oublier de libérer la mémoire ! Tu as de grosses fuites de mémoires là.
Un tableau commence à l'indice 0 et pas à l'indice 1

[Stéphoune]

Nickel! Ca marche super. Enfin, dans mon cas d'école en tout cas. J'applique ça à mon graphe et je regarde si ça marche.

Juste pour mon info, le free est-il systématiquement nécessaire? Dans notra cas, le fait de refaire un malloc sur ma variable ne suffit-il pas à libérer ma mémoire?

[Pouet_forever]

Certains te dirons que le free n'est pas obligatoire parce que les OS modernes libèrent automatiquement la mémoire ...
Mais dans ton cas tu es obligé de libérer, sinon tu fais des fuites de mémoires. Un malloc ne fais pas de libération de mémoire, il ne fait qu'allouer.

[Stéphoune]

Perfect! Ca fonctionne du tonnerre, même dans mon graphe. Merci du tuyau