Liberer la mémoire d'une structure

Version imprimable

09/05/2018, 15h01
delisiouz

Liberer la mémoire d'une structure
Bonjour, j'ai cette structure et je n'arrive pas a libéré la mémoire de la structure quand je n'en ai plus besoin. Pouvez-vous m'aidez?
Code:

1 2 3 4 5 6 7 8 9 10 11 typedef struct { char *line; int size_max; int curr_size; } LINE; typedef struct { LINE** lines; int curr_size; int curr_max; } BUFF;
Sachant que curr_size correspond au nombre de ligne; et size a la taille de la chaine.

Merci.
09/05/2018, 15h21
Matt_Houston

Comment est allouée la mémoire ? Qu'est-ce qui te pose des difficultés précisément ?

Voila comment j'alloue ma structure.

Code:

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
LINE *lire_ligne(FILE *f){// fonction qui lit une ligne et la met dans la structure
  char c;
  int k = 0;
  LINE *ligne = NULL;
  if ((c = fgetc(f)) != EOF) {
    ligne = (LINE *) malloc(sizeof(LINE));
    ligne -> size_max = MAX_LENGTH;//1024
    ligne -> line = (char*) malloc((1 + MAX_LENGTH) * sizeof(char));///<-----valgrind pb
    while (c != EOF && c != '\n') {
      ligne -> line[k++] = c;
      c = fgetc(f);
    }
  }
  if (ligne != NULL) {
    ligne -> curr_size = k;
    ligne -> line[k] = '\0';
  }
  return ligne;
}
 
BUFF* remplir_buffer(char* nom_fichier){
  BUFF *buffer = (BUFF*) malloc(sizeof(BUFF));
  buffer -> size_max = BUFF_SIZE;//200
  buffer -> curr_size= 0;
  buffer -> content_buff  =
    (LINE**) calloc(BUFF_SIZE, sizeof(LINE *));
  FILE* fichier = ouverture(nom_fichier, "r");
  int i = 0;
  LINE* line = NULL;
  do {
    line = lire_ligne(fichier);
    if (line != NULL) {
      buffer -> content_buff[i] = line;
      buffer -> curr_size++;
      i++;
    }
  } while (line != NULL);
  fclose(fichier);
  return buffer;
}

et quand je fait valgrind j'ai un probleme avec cette ligne

Code:

ligne -> line = (char*) malloc((1 + MAX_LENGTH) * sizeof(char));

Citation:

Envoyé par delisiouz

j'ai un probleme

C'est-à-dire ? Comment ça se manifeste ? Comment veux-tu qu'on devine ce qu'il se passe ? :roll:

En ce qui concerne la libération de la mémoire il y a deux règles simples qui répondent à la plupart des cas d'usage :

ton code doit comporter autant de free que de malloc ;
les appels à free doivent être réalisés dans l'ordre inverse des appels à malloc, comme on ferait usage d'une pile. On évite ainsi de libérer des enregistrements alloués dynamiquement avant leurs champs internes, par exemple.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 typedef struct { char *bar; } foo_t; // ... { foo_t *foo = malloc(sizeof *foo); if (foo) { foo->bar = malloc(256); if (foo->bar) { // ... } free(foo->bar); // alloc @ line 10 } free(foo); // alloc @ line 8 }

09/05/2018, 16h43
delisiouz

Je dois faire mes free dans la fonction ou j'alloue ? Mais ca ne va pas me supprimer ma structure sans que je puisse l'utilisé?
09/05/2018, 17h07
Matt_Houston

Non, tu peux bien sûr appeler free n'importe quand entre l'allocation (réussie ou non puisque free(NULL) est autorisé) et la fin du programme. Tu dois lui fournir l'adresse exacte renvoyée par l'appel à malloc auquel elle fait référence.

Citation:

Envoyé par delisiouz

Je dois faire mes free dans la fonction ou j'alloue ?

Bonjour

Pas forcément. Tu peux allouer dans une fonction X (en renvoyant donc ce qui a été alloué). Donc toi quand tu appelles fonctionX() tu récupères le pointeur alloué, tu l'utilise tant que tu veux et ensuite, quand tu n'en as plus besoin, tu le libères.

Exemple
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 int *rempir(int n) { int *pt; pt=malloc(sizeof(int)); if (pt == NULL) return NULL; *pt=n; return pt; } int main() { int *valeur; valeur=remplir(123); if (valeur == NULL) { printf("Hum... quelque chose s'est mal passé - Désolé, le programme ne peut pas continuer\n"); return -1; } printf("Ma valeur vaut %d\n", *valeur); free(valeur); return 0; }
Ca fonctionne parce que l'allocation se fait dans une zone mémoire (qu'on appelle "le tas") accessible par tout le programme. Donc ce n'est pas parce qu'on quitte la fonction que ce qui a été alloué est libéré.

10/05/2018, 09h28
exe2bin

Citation:

Envoyé par delisiouz

Je dois faire mes free dans la fonction ou j'alloue ? Mais ca ne va pas me supprimer ma structure sans que je puisse l'utilisé?

Non comme on te l'a expliqué ,et c'est bien pour cette raison qu'il faut utiliser free à un moment ou à un autre ,pour palier
aux fuites de mémoire.
Tu n'as qu'à imaginer la fonction malloc() comme une fonction qui réserve une certaine quantité de mémoire utilisable
n'importe où dans ton code et qui peut même perdurer après sa terminaison !
C'est ainsi que le programmeur C doit libérer lui même la mémoire qu'il s'est octroyé !