Discussion :

[delisiouz]

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 :

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

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.

[Matt_Houston]

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

[delisiouz]

Voila comment j'alloue ma structure.

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
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 :

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

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

[Matt_Houston]

j'ai un probleme

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

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 :

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
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
}

[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é?

[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.

[Sve@r]

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 c :

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
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é.

[exe2bin]

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é !