Listes Chainées et libération mémoire?

**alexglvr** · 14/01/2011, 17h49

Bonjour,

Je travail sur un projet en C dans lequel j'utilise de longues listes chainées...

Voici un exemple de liste :

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
struct data_POSS
{
   int valide;
   int Tab1[50];
   int Tab2[200];
};
 
struct node_POSS
{
   struct data_POSS data;
   struct node_POSS *psuiv;
   struct node_POSS *pprec;
};
 
struct liste_POSS
{
   struct node_POSS *pTete;
   struct node_POSS *pQueue;
   int Nb_Elements;
};

Ensuite je l'instancie de la manière suivante :

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
void add_POSS (struct liste_POSS *p_liste, struct data_POSS *p_data)
{
   struct node_POSS *pNouveau = malloc (sizeof *pNouveau);
   if (pNouveau != NULL)
   {
      pNouveau->data = *p_data;
      pNouveau->psuiv = NULL;
 
      if (p_liste->pTete == NULL)
      {
      /* Premier maillon = Premiere Ligne */
         p_liste->pTete = pNouveau;
         pNouveau->pprec = NULL;
      }
      else
      {
         p_liste->pQueue->psuiv = pNouveau;
         pNouveau->pprec = p_liste->pQueue;
      }
      p_liste->pQueue = pNouveau;
   }
}
 
void Create_liste (struct liste_POSS *p_POSS)
{
  int i, j;
  struct data_POSS data_CP;
 
  p_POSS->Nb_Elements = 0;
 
  for (i=0;i<65534;i++)
    {
	data_CP.valide=1;
	for (j=0;j<50;j++) {data_CP.Tab1[j]=0;}
	for (j=0;j<200;j++) {data_CP.Tab2[j]=0;}
 	add_POSS(p_POSS, &data_CP);
	p_POSS->Nb_Elements = p_POSS->Nb_Elements + 1;
     }                                        
}

Dans mon Main.c j'appelle la fonction Create_liste afin de créer une chaine.
Après, avoir travaillé sur cette chaine j'essaie de la réinitialiser en rappelant la fonction Create_liste...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void Main ()
{
     int i;
     struct liste_POSS TOTO_liste = {NULL, NULL, 0};
 
     for (i=0;i<5;i++) 
     {
          Create_liste(&TOTO_liste);
 
        // UTILISATION et TRAITEMENT DE LA LISTE
 
     }

Or, la fonction Create_liste ne donne pas a chaque fois le même nombre d'éléments dans la liste chainée... au début j'ai bien 35535, puis ensuite ca diminue...
Mon programme est assez gros, et utilise beaucoup de liste et liste de liste...
Aussi, je me suis dit que c'etait peut etre un probleme mémoire et j'ai ajouté:

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
void liberation_Mem (struct liste_POSS *C_POSS)
{
     struct node_POSS *p_sw = C_POSS->pTete;
     struct node_POSS *p_tmp;
 
     while (p_sw!=NULL)
     {
           p_tmp = p_sw->psuiv;
           free(p_sw);
           C_POSS->pTete = p_tmp;
 
           p_sw = C_POSS->pTete;
     }    
}
 
void Main ()
{
     int i;
     struct liste_POSS TOTO_liste = {NULL, NULL, 0};
 
     for (i=0;i<5;i++) 
     {
          Create_liste(&TOTO_liste);
 
        // UTILISATION et TRAITEMENT DE LA LISTE
 
          liberation_Mem (&TOTO_liste );
 
     }

Est ce que la libération de mémoire est correcte?

Merci pour votre aide,

Alex

**Médinoc** · 14/01/2011, 18h03

D'ici, ça a l'air correct.

Simplement, tu devrais peut-être remettre les pointeurs à NULL dans la structure, au cas où on tenterait d'y accéder après libération...

**quetzacoatl** · 14/01/2011, 18h08

Il y a quelque chose d'étrange dans votre fonction "add_POS", vous faites:

struct node_POSS *pNouveau = malloc (sizeof *pNouveau);

Alors qu'a priori pNouveau n'est pas un type mais un élément
Vous vouliez faire j'imagine:

struct node_POSS *pNouveau = malloc (sizeof ( struct node_POSS));

**Médinoc** · 14/01/2011, 19h00

^Non, c'est la manière correcte de faire.
Ainsi, si le type de pNouveau est modifié, il y aura moins de remplacements à faire.

La seule difficulté c'est de ne pas oublier l'étoile.

**alexglvr** · 14/01/2011, 20h32

Merci pour votre aide !

Du coup, si c'est bon, je ne comprends pas pourquoi Create liste ne crée pas toujours 65534 cellules...

Si je vérifie comme ça 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
20
21
22
23
24
25
void Create_liste (struct liste_POSS *p_POSS)
{
  int i, j, COmpteur;
  struct data_POSS data_CP;
 
  p_POSS->Nb_Elements = 0;
 
  for (i=0;i<65534;i++)
    {
	data_CP.valide=1;
	for (j=0;j<50;j++) {data_CP.Tab1[j]=0;}
	for (j=0;j<200;j++) {data_CP.Tab2[j]=0;}
 	add_POSS(p_POSS, &data_CP);
	p_POSS->Nb_Elements = p_POSS->Nb_Elements + 1;
     }      
 
     struct node_POSS *p_swp =  p_POSS->pTete;
     while (p_swp!=NULL)
     {
         COmpteur++;
         p_swp = p_swp->psuiv;
      }
     printf("%d\t%d\r\n", p_POSS->Nb_Elements, COmpteur);
 
}

On obtient toujours p_POSS->Nb_Elements = 65534 mais COmpteur peut avoir une autre valeur...

Y a t il une solution pour voir combien de mémoire le programme utilise ???

Car j'avais déjà des plantages "aléatoires" du programme que j'ai résolus en ajoutant la fonction "liberation_Mem"... Du coup, je me dis que ça doit encore être du à ça...

**quetzacoatl** · 15/01/2011, 01h28

Je pense que le problème vient peut-être de votre fonction

void add_POSS (struct liste_POSS *p_liste, struct data_POSS *p_data)

En effet, vous y faites

pNouveau->data = *p_data;

Or *p_data contient deux tableaux, vous n'allez donc pas recopié les tableaux de cette façon , et pire encore une partie de la mémoire réservée par votre malloc ne sera plus accessible.

**alexglvr** · 15/01/2011, 12h02

Je ne comprends pas pourquoi...

**quetzacoatl** · 15/01/2011, 13h30

Ecrire quelque chose du genre tab1=tab2 ne recopie pas tab2 dans tab1, les tableaux étant en réalité des pointeurs, on affecte au pointeur tab1 qui pointe sur la première case d'un tableau, l'adresse de la premiere case de tab2.
Ainsi tab1 pointe sur la première case de tab2, mais il n'y a pas de recopie comme on désirait.
Et je pense que l'espace mémoire réservé par tab1 n'étant plus pointée, cela peut peut-être causé des soucis.

Pour recopier les tableaux il faut utilisr des fonctions du genre memcpy()

**diogene** · 15/01/2011, 20h17

Dans Create_liste(), COmpteur n'est pas initialisé à 0 , d'où des résultats farfelus

.

**alexglvr** · 15/01/2011, 20h51

ça c'est une erreur de saisie... quand j'ai écrit le code sur le forum...
Compteur est bien initialisé !

Et au fur et a mesure des ré initialisation de la liste, le nombre d'éléments décroit...

Je vais ajouter ça, ca me donnera surement plus d'info...

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
 
void add_POSS (struct liste_POSS *p_liste, struct data_POSS *p_data)
{
   struct node_POSS *pNouveau = malloc (sizeof *pNouveau);
 
   if (pNouveau != NULL)
   {
      pNouveau->data = *p_data;
      pNouveau->psuiv = NULL;
 
      if (p_liste->pTete == NULL)
      {
      /* Premier maillon = Premiere Ligne */
         p_liste->pTete = pNouveau;
         pNouveau->pprec = NULL;
      }
      else
      {
         p_liste->pQueue->psuiv = pNouveau;
         pNouveau->pprec = p_liste->pQueue;
      }
      p_liste->pQueue = pNouveau;
   }
   else // l'allocation a échoué
  { 
    printf("C'est la que ca merde !\r\n");
  }
 
}

**jeroman** · 15/01/2011, 23h02

Envoyé par alexglvr

ça c'est une erreur de saisie... quand j'ai écrit le code sur le forum...

Pourquoi tu t'embêtes à retaper le code à la main ?

Utilise le copié/collé, ça va te simplifier énormément la vie.

**alexglvr** · 16/01/2011, 11h35

Pourquoi tu t'embêtes à retaper le code à la main ? Utilise le copié/collé, ça va te simplifier énormément la vie.

Par ce que le code réel est beaucoup trop gros pour être posté, du coup, j'ai fait un petit code spécial qui montre mon problème ! Ça prend deux minutes, et ça simplifie la compréhension...

**diogene** · 16/01/2011, 12h54

Par ce que le code réel est beaucoup trop gros pour être posté, du coup, j'ai fait un petit code spécial qui montre mon problème !

C'est une bonne idée, mais fait alors un copier/coller du code spécial qui montre le problème. Si le code de test que tu montres est faux, on ne va pas s'en sortir.

Personnellement, en exécutant le code que tu proposes (si j'ai bien rassemblé les différents morceaux) et après correction des erreurs pour que ça compile, je ne constate pas de problèmes.

J'ai pris : Create_liste() du post #5 (et corrigé COmpteur), add_POSS() du post #10, les définitions du post #1, le main (après correction)du post #1 et ensuite aussi l'ensemble liberation_Mem()+ main (après correction) du post #1 et enfin ajouté les deux #include manquant.

**alexglvr** · 16/01/2011, 13h45

La première itération fonctionne chez moi, mais après non (avec le code complet).

Mais je pense que c'est du à un pb de mémoire...
Y a t il une limite mémoire à ne pas dépasser??

Le vrai code génère des dizaines de listes chainées / arbres pouvant contenir plusieurs millions de cellules...

Je vais tester ce soir ou demain si l'erreur se produit bien lors du malloc...

JE vous tiens au courant !

Alex

**alexglvr** · 17/01/2011, 10h58

J'ai fait le test en ajoutant dans add_POSS une notification si l'allocation de mémoire echoue...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void add_POSS (struct liste_POSS *p_liste, struct data_POSS *p_data)
{
   struct node_POSS *pNouveau = malloc (sizeof *pNouveau);
 
   if (pNouveau != NULL)
   {
     ....
   }
   else // l'allocation a échoué
  { 
    printf("C'est la que ca merde !\r\n");
  }

Et c'est bien ca...

A la première itération c'est bon (il reste encore assez de mémoire pour que le programme fonctionne), par contre, à la suivante, les erreurs d'allocation commencent....

Pourtant entre les deux je fais une libération mémoire....

Bon, je vais réfléchir à une solution moins gourmande en mémoire...

**cyberboss** · 18/01/2011, 01h48

Tu peux tester avec un valgrind =)

**souviron34** · 19/01/2011, 13h14

Envoyé par alexglvr

Pourtant entre les deux je fais une libération mémoire....

Bon, je vais réfléchir à une solution moins gourmande en mémoire...

ne jamais oublier que free ne libère pas réellement la mémoire, sauf si c'est la toute dernière partie de la mémoire.. Schéma déjà donné de multiples fois...

Une manière de faire qui, bin que ne garantissant pas la vraie libération, la favorise (si il n'y a pas d'autres allocation ailleurs entretemps), c'et de libérer en sens inverse de l'allocation : commencer par la fin...

Listes Chainées et libération mémoire?

C

Discussions similaires

Partager

Partager