Problème de gestion de liste chainée

Problème de gestion de liste chainée - C - Programmation

Marsh Posté le 16-04-2006 à 17:45:24    

Bonjour à tous.
 
Je dois réaliser un programme qui simule la gestion de mémoire d'un ordinateur, via liste chaînée.
Avec ce que j'ai fait, j'ai pu créer un processus. Mais dès que j'en crée un, il m'est impossible d'en créer un autre sans avoir de plantage au milieu. De plus, quand je veux afficher ma liste, j'ai un plantage lorsque j'ai créé un processus, sinon ça va (mais bon, sans processus, ça me fait un bloc à afficher, pas trop utile).
 
Je soupçonne mes pointeurs de se ballader un peu comme ils veulent, malheureusement, j'ai beau refaire le cheminement de mon programme sur une feuille de papier, je ne comprends pas ce qui se passe. De fait, une aide serait la bienvenue svp.
 
Voici le code (sans toutes les fonctions, uniquement celles utilisées) :  
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. typedef struct {
  6.   int numero, debut, taille;
  7.   char *tache;
  8.   char *utilisateur; } ELEMENT;
  10. typedef struct chainon {
  11.   ELEMENT val;
  12.   struct chainon *suiv; } CHAINON, *LISTE;
  14. LISTE creer(void)
  15. {
  16.   char utilisateur[]="---";
  17.   char tache[]="---";
  18.   LISTE init = malloc(sizeof(init));
  19.   if (init) init->suiv = NULL;
  20.   else printf("Erreur ! Memoire insuffisante !" );
  22.   init->val.debut=0;
  23.   init->val.utilisateur = malloc(strlen(utilisateur));
  24.   init->val.tache = malloc(strlen(tache));
  25.   strcpy(init->val.utilisateur,utilisateur);
  26.   strcpy(init->val.tache,tache);
  28.   return init;
  29. }
  31. int listevide(LISTE l){
  32.   if (l->suiv == NULL) return(1);
  33.   else return(0);
  34. }
  36. LISTE ajouter(LISTE l, ELEMENT e){
  37.   LISTE p;
  38.   p=l;
  39.   while (((e.taille) > (p->val.taille)) && ((p->val.numero) != 0))
  40.     p=p->suiv;                                         
  42.   if (p == NULL)
  43.   {
  44.     printf("Taille de tache trop grande ou pas de bloc libre disponible.\n" );
  45.     return(l);
  46.   }
  47.  
  48.   else
  49.   {
  50.     if ((e.taille) == (p->val.taille))
  51.     { /* Taille du bloc = taille du processus a ajouter */
  52.       p->val.numero=e.numero;
  53.       p->val.tache=malloc(sizeof(e.tache));
  54.       p->val.utilisateur=malloc(sizeof(e.utilisateur));
  55.       strcpy(p->val.tache,e.tache);
  56.       strcpy(p->val.utilisateur,e.utilisateur);
  57.       return(l);
  58.     }
  59.     else {
  60.       /* Taille du bloc > taille du processus a ajouter */
  61.       /* Creation de bloc supplementaire */
  62.       LISTE g;
  63.       g = malloc(sizeof(CHAINON));
  64.       g->suiv=p->suiv;
  65.       g->val.numero=0;
  66.       g->val.taille=((p->val.taille)-(e.taille));
  67.       g->val.debut=((p->val.debut)+(e.taille));
  68.       p->suiv=g;
  69.       p->val.numero=e.numero;
  70.       p->val.taille=e.taille;
  71.       p->val.tache=malloc(sizeof(e.tache));
  72.       p->val.utilisateur=malloc(sizeof(e.utilisateur));
  73.       strcpy(p->val.tache,e.tache);
  74.       strcpy(p->val.utilisateur,e.utilisateur);
  75.       return(l);
  76.     }
  77.   }
  78. }
  80. LISTE rechercheou(LISTE l, ELEMENT e){
  81.   LISTE p;
  82.   p=l;
  83.   /* d'abord les tests numeriques */
  84.   printf("p->val.numero = %d\n",p->val.numero);
  85.   printf("e.numero = %d",e.numero);
  86.   if (listevide(l) == 1) {return(p); printf("\nArret 1bis ok\n" ); }
  87.   else while ((p->val.numero != e.numero) || (p->val.debut != e.debut) || (p->val.taille != e.taille) || (strcmp(p->val.tache,e.tache) != 0) || (strcmp(p->val.utilisateur,e.utilisateur) != 0 ))
  88.   {
  89.     p=p->suiv;
  90.     printf("\nArret 2bis ok\n" );
  91.   }
  92.   printf("\nArret 3bis ok\n" );
  93.   return(p); /* On retourne p, qui indiquera soit l'element trouve, soit NULL si pas de resultat */
  94. }
  96. void affiche(LISTE l){
  97.   printf("Bloc Numero : %d\n",l->val.numero);
  98.   printf("Taille      : %d\n",l->val.taille);
  99.   printf("Debut       : %d\n",l->val.debut);
  100.   printf("Utilisateur : %s\n",l->val.utilisateur);
  101.   printf("Tache       : %s\n",l->val.tache);
  102.   printf("------------------\n" );
  103. }
  105. void afficheliste(LISTE l){
  106.   LISTE p;
  107.   p=l;
  108.   while (p != NULL){
  109.     affiche(p);
  110.     p=p->suiv;
  111.   }
  112. }
  114. /* Après définition de ces fonctions de gestion de listes chainées, on va coder les fonctions de gestion de la mémoire */
  116. LISTE bloclibre(LISTE mem,int taille){
  117.   LISTE p;
  118.   int ok=0;
  119.   ELEMENT e;
  120.   e.numero=0;
  121.   e.taille=mem->val.taille;
  122.   printf("\nArret 1 ok\n" );
  123.   while (ok != 1){
  124.     p=rechercheou(mem,e);
  125.     printf("\nArret 2 ok\n" );
  126.     if (listevide(p) == 1){
  127.       return(p);
  128.       ok=1;
  129.     }
  130.   printf("\nArret 3 ok\n" );
  131.     if (p->val.taille >= taille){
  132.       p=p->suiv;
  133.   printf("\nArret 4 ok\n" );
  134.       bloclibre(p,taille);
  135.     }
  136.     else {
  137.       ok=1;
  138.       printf("\nArret 5 ok\n" );
  139.       return(p);
  140.     }
  141.   }
  142. }
  144. ELEMENT allouebloc(int taille, int numero, int debut, char *u, char *t){
  145.   ELEMENT e;
  146.   e.taille=taille;
  147.   e.numero=numero;
  148.   e.debut=debut;
  149.   e.utilisateur = malloc(strlen(u));
  150.   e.tache = malloc(strlen(t));
  151.   strcpy(e.utilisateur,u);
  152.   strcpy(e.tache,t);
  153.   return(e);
  154. }
  156. LISTE nouvelletache(LISTE mem, int taille, int numero, int debut, char *u, char *t){
  157.   ELEMENT e;
  158.   e=allouebloc(taille,numero,debut,u,t);
  159.   ajouter(mem,e);
  160. }
  162. int numeroprocess(int k){
  163.   return(k+1);
  164. }
  166. int main(void){
  167.   LISTE L,p;
  168.   int k=0;
  169.   int action,taille,num;
  170.   char utilisateur[20];
  171.   char tache[20];
  173.   L=creer();
  174.   L->val.taille=512; /* taille de ma liste */
  175.   printf("Bienvenue dans l'interpreteur de commande\n" );
  176.   printf("Tapez 5 pour l'aide\n" );
  178.   while(fin != 1){
  179.     printf("Que voulez-vous faire?\n" );
  180.     scanf("%d",&action);
  181.       if (action == 1){
  182. printf("Fonction Ajouter\n" );
  183. printf("Utilisateur  " );
  184. scanf("%s",utilisateur);
  185. printf("\nTache:   " );
  186. scanf("%s",tache);
  187. printf("\nTaille:    " );
  188. scanf("%d",&taille);
  189. p=bloclibre(L,taille);
  190. printf("\n Valeurs pour le bloc libre p : debut %d taille %d\n",p->val.debut,p->val.taille);
  191. printf("\nTache de %s intitulee %s de taille %d\n",utilisateur,tache,taille);
  192. nouvelletache(L,taille,numeroprocess(k),p->val.debut,utilisateur,tache);
  193. k++;
  194.       }
  195.       if(action == 3){
  196. printf("Fonction Affichage\n" );
  197. afficheliste(L);
  198.       }
  199.     }
  200.   }
  201. return 0;
  202. }


 
(les printf("Arret" ); me servent à savoir, avec les tests ci-dessous, à quel niveau mon programme plante)
 
Quelques tests :  
 
Je ne crée rien et affiche directement la liste, aucun problème :  

Citation :


Fonction Affichage
Bloc Numero : 0
Taille      : 512
Debut       : 0
Utilisateur : ---
Tache       : ---
------------------


Je crée un processus uniquement, aucun problème :  

Citation :


Fonction Ajouter
Utilisateur  lordji
 
Tache:   gaim
 
Taille:    50
 
Arret 1 ok
p->val.numero = 0
e.numero = 0
Arret 2 ok
 
 Valeurs pour le bloc libre p : debut 0 taille 512
 
Tache de lordji intitulee gaim de taille 50


J'en crée un autre tout de suite après, j'ai droit à un freeze à la fin de ce qui s'affiche en dernier, le programme a l'air de boucler un peu, puis ma console (sous win) plante ("ce programme va se terminer (...)" ) :

Citation :


Fonction Ajouter
Utilisateur  lordji
 
Tache:   gcc
 
Taille:    120
 
Arret 1 ok
p->val.numero = 1
e.numero = 0
Arret 2bis ok
 
Arret 2bis ok


Quand, après avoir créé un seul processus, je demande l'affichage de ma liste, j'ai de même que ci-dessus, un freeze (avec tournage en rond avant) ; ce qui me surprend, c'est qu'il n'affiche pas les deux dernières chaînes de caractère :

Citation :


Fonction Affichage
Bloc Numero : 1
Taille      : 50
Debut       : 0
Utilisateur : lordji
Tache       : gcc
------------------
Bloc Numero : 0
Taille      : 462
Debut       : 50


 
Voilà, c'est un peu long, désolé, mais c'est pour clarifier au maximum la chose.
D'avance merci.

Message cité 1 fois
Reply

Marsh Posté le 16-04-2006 à 17:45:24   

Reply

Marsh Posté le 16-04-2006 à 19:29:31    

LorDjidane a écrit :


Voici le code (sans toutes les fonctions, uniquement celles utilisées) :  


Ne compile pas


Compiling: main.c
main.c: In function `main_':
main.c:178: error: `fin' undeclared (first use in this function)
main.c: At top level:
main.c:201: error: syntax error before "return"
main.c: In function `allouebloc':
main.c:144: warning: function returns an aggregate
main.c: In function `nouvelletache':
main.c:158: warning: function call has aggregate value


  • Ajouté int fin = 0;
  • Supprimé } en trop dans main()
  • Il est extrèmement confusant de cacher les pointeurs. Je supprimme donc le type LISTE.
  • De plus il nomme un pointeur sur un noeud, ce qui est encore plus confusant. Le type 'liste 'est plutôt une structure comprenant le pointeur de tête et le pointeur de fin de la liste... Je me réserve la possibilité de rebâtir un type 'liste' pour simplifier le codage ...
  • bloclibre() : Inutile de mettre du code après un return, il ne sera pas exécuté...
  • bloclibre() : algo tordu. Eviter les return au mileu des boucles. Utiliser break, les flags, un return unique...
  • allouebloc() : structure locale etrange. Une allocation, c'est dynamique. Là, il y a un mélange de copie et d'allocation... Pas clair et très douteux...
  • nouvelletache() ne retourne rien malgré son prototype...
  • bref, c'est un peu n'importe quoi tout ça...

Je te conseille de commencer par travailler sur les listes chainées sans trop de préoccuper des données (un simple 'int' de contrôle suffit). Ensuite, tu compliques en mettant des données plus complexes. une structre allouée dynamiquement, par exemple...


Message édité par Emmanuel Delahaye le 16-04-2006 à 19:55:38

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed