1. #1
    Membre à l'essai
    Femme Profil pro
    Étudiant
    Inscrit en
    avril 2016
    Messages
    32
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : avril 2016
    Messages : 32
    Points : 24
    Points
    24

    Par défaut 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 : 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.

  2. #2
    Membre expert
    Inscrit en
    mars 2005
    Messages
    1 256
    Détails du profil
    Informations forums :
    Inscription : mars 2005
    Messages : 1 256
    Points : 3 633
    Points
    3 633

    Par défaut

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

  3. #3
    Membre à l'essai
    Femme Profil pro
    Étudiant
    Inscrit en
    avril 2016
    Messages
    32
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : avril 2016
    Messages : 32
    Points : 24
    Points
    24

    Par défaut

    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));

  4. #4
    Membre expert
    Inscrit en
    mars 2005
    Messages
    1 256
    Détails du profil
    Informations forums :
    Inscription : mars 2005
    Messages : 1 256
    Points : 3 633
    Points
    3 633

    Par défaut

    Citation Envoyé par delisiouz Voir le message
    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
    }

  5. #5
    Membre à l'essai
    Femme Profil pro
    Étudiant
    Inscrit en
    avril 2016
    Messages
    32
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : avril 2016
    Messages : 32
    Points : 24
    Points
    24

    Par défaut

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

  6. #6
    Membre expert
    Inscrit en
    mars 2005
    Messages
    1 256
    Détails du profil
    Informations forums :
    Inscription : mars 2005
    Messages : 1 256
    Points : 3 633
    Points
    3 633

    Par défaut

    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.

  7. #7
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    6 264
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 6 264
    Points : 17 565
    Points
    17 565
    Billets dans le blog
    1

    Par défaut

    Citation Envoyé par delisiouz Voir le message
    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é.
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  8. #8
    Membre averti
    Avatar de exe2bin
    Profil pro
    Passionné de programmation
    Inscrit en
    mars 2009
    Messages
    493
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Passionné de programmation

    Informations forums :
    Inscription : mars 2009
    Messages : 493
    Points : 323
    Points
    323
    Billets dans le blog
    3

    Par défaut

    Citation Envoyé par delisiouz Voir le message
    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é !

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. preallocation de la mémoire pour une structure
    Par kawther dans le forum Interfaces Graphiques
    Réponses: 2
    Dernier message: 03/07/2009, 10h41
  2. Réponses: 12
    Dernier message: 16/10/2008, 11h17
  3. Réponses: 2
    Dernier message: 19/02/2007, 15h46
  4. Réponses: 6
    Dernier message: 24/03/2006, 18h24

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo