Discussion :

[kimikou]

Bonjour,

Voici la partie du code qui me pose problème :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
typedef struct test {
  int **mat;
  int x;
  int y;
  int c;
 
  struct test *prec;
} test_t;
 
static void mat_free (int ** mat)
{
  for (int i = 0; i < TAILLE; i++)
    free (mat[i]);
 
  free (mat);
}
 
static void pile_free(test_t *pile)
{
    if (pile != NULL)
    {
        if (pile->prec != NULL)
           pile_free(pile->prec);
 
       mat_free(pile->mat);
       free(pile);
   }
}
 
int** mat_copy (int **mat)
{
  int **cpy = mat_alloc();
  for (int  i = 0 ; i < TAILLE ; i++)
    memcpy (cpy[i], mat [i], TAILLE * sizeof (int));
 
  return cpy;
}
 
test_t *push(test_t *pile, int ***mat)
{
  test_t *elem_prec = malloc(sizeof(test_t));
 
  elem_prec->mat=mat_copy(*mat);
 
  /*******************************************************
  divers calculs pour trouver le x, y et c de la structure
  ********************************************************/
 
  elem_prec->x = x;
  elem_prec->y = y;
  elem_prec->c = c;
 
  if (pile == NULL)
    elem_prec->prec = NULL;
  else
    elem_prec->prec = pile;
  pile = elem_prec;
  (*mat)[pile->x][pile->y] = pile->c;
  return pile;
}
 
test_t *pile = NULL;
 
bool f (int **mat)
{
  switch (test_mat(mat)) //divers calculs qui vont modifiés 'mat' et renvoyés un entier
    {
    case (0) :
      pile_free(pile);
      return 0;
 
    case (1) :
      pile = push(pile, &(mat));	 
      return f(mat);
 
    default :
      return 1;
    }
 
  return 1;
}

Mon problème se trouve au niveau de la mémoire : je ne sais pas à quel moment libérer la mémoire allouée par 'mat_copy' dans 'push'. Valgrind m'indique donc que de nombreux bits sont perdus.

Merci d'avance pour toutes aides.

[Sve@r]

Salut
Ta question est bizarre. Tu alloues des octets parce que tu en as besoin donc tu sais où les récupérer et aussi quand tu n'en as plus besoin. Donc tu libères à ce moment là !!!

[gangsoleil]

Bonjour,

L'ideal est d'etre symetrique dans un programme, c'est a dire que c'est la meme maniere de proceder pour allouer et pour desallouer ; par exemple, on peut dire que c'est a l'appelant d'allouer et de liberer la memoire, en fonction de ses besoins :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
// bla bla bla
// J'ai besoin de memoire, donc j'en alloue
valeur_de_retour = mon_allocation (ma_taille)
// traitement des cas d'erreur
 
//Maintenant je peux travailler avec la taille allouee
 
// Je n'ai plus besoin de la zone memoire, je la libere
val_retour2 = mon_free (valeur_de_retour)
 
// bla bla bla

On trouve aussi, malheureusement, quelques fonctions qui allouent toutes seules la zone memoire, et c'est a l'appelant de la liberer. Generalement source de bug, meme si ce n'est pas, theoriquement parlant, mieux ou moins bien.