Passage de pointeurs en paramètre erronés !

Passage de pointeurs en paramètre erronés ! - C - Programmation

Marsh Posté le 20-02-2004 à 13:45:37    

Bonjour,
j'ai encore un petit soucis avec les pointeurs que je ne maitrise toujours pas completement...
 
J'ai deux fonctions, une fontion qui me charge une liste chainée (horizontalement et verticalement) et une fonction qui m'affiche cette liste dans le terminal.
 
Voici les signatures des méthodes :

Code :
  1. struct jour* chargeAgenda(char unFichier[100],struct jour **j)
  2. int afficher(struct jour *j)


 
En fait le problème est que qd j'appelle ma fontion afficher() de ma fonction chargeAgenda il m'affiche bien ma liste et il n'y a pas d'erreur.
Par contre qd j'efface cet appel de ma méthode chargeAgenda. et que je créé un main de ce type :
 

Code :
  1. int main (int argc, char **argv) {
  3.   struct jour *j;
  5. ...
  6. ...
  8.   j = chargeAgenda(argv[1],&j);
  10.   afficher(j);


 
Et benh la liste n'est plus du tout bonne, alors je charge a partir du meme fichier. Il me créé une liste infinie avec des valeurs complètement aléatoire.
 
Merci de me dépanner, je sais je pose beaucoup de poste. Mais la je suis vraiment bloquer.

Reply

Marsh Posté le 20-02-2004 à 13:45:37   

Reply

Marsh Posté le 20-02-2004 à 13:59:18    

Bon..déjà je vois pas pourquoi tu passe J et en paramètre, et en valeur de retour..
A priori c'est l'un ou l'autre mais pas les deux. (étant donné que tu ne renvoi qu'une chose, je dirais en valeur de retour)
 
Ensuite faudrait montrer un petit peu du code.. genre la fonction
chargeAgenda.
Dans chargeAgenda, voila ce que tu fais :  
t'alloue ta structure jour
tu la remplie avec les données de ton fichier
et tu la renvoi
return monBidouillage
 

Reply

Marsh Posté le 20-02-2004 à 14:11:21    

Voici la fonction chargeAgenda, ne chambrer pas trop... je débute en C.. :pt1cable:  
 

Code :
  1. struct jour* chargeAgenda(char unFichier[100]) {
  2.  
  3.   struct jour *j;
  4.   int i = 2;// incrment pour les lignes.
  5.   struct rdv unRdv;//le rdv avec lequel on va commencer la liste.
  6.   double diff;//diffrence en seconde entre deux dates.Sert a tudier la chronologie.
  7.   struct jour *p;//pointeur qui nous permet de parcourir la liste.
  8.   struct jour *precedentP;//precedent du pointeur qui parcoure la liste.
  9.   time_t tTest;
  12.   j = malloc(sizeof(struct jour));
  13.   j->unRdvAgenda = malloc(sizeof(struct rdvAgenda));
  14.   j->jourSuivant = malloc(sizeof(struct jour));
  16.   p = malloc(sizeof(struct jour));
  17.   precedentP = malloc(sizeof(struct jour));
  18.   p->unRdvAgenda = malloc(sizeof(struct rdvAgenda));
  19.   precedentP->unRdvAgenda = malloc(sizeof(struct rdvAgenda ));
  20.   p->jourSuivant = malloc(sizeof(struct jour));
  21.   precedentP->jourSuivant = malloc(sizeof(struct jour));
  24.   initializeFile(unFichier);// initialisation du fichier.
  26.   readRDV(&unRdv,1);// lit le premier rdv  la ligne 1.
  28.   j->dateDuJour = unRdv.dateDebut;
  29.   j->jourSuivant = NULL;
  30.   j->unRdvAgenda->leRdv.dateDebut = unRdv.dateDebut;
  31.   j->unRdvAgenda->leRdv.dateFin = unRdv.dateFin;
  32.   strcpy(j->unRdvAgenda->leRdv.libelle, unRdv.libelle);
  33.   j->unRdvAgenda->leRdvAgendaSuivant = NULL;
  35.   while ( !eof() ) {
  37.     struct rdv rdvTmp;
  38.    
  39.     readRDV(&rdvTmp,i);
  41.     p = j;
  42.     precedentP = NULL;
  43.    
  44.  
  45.     if ( rdvTmp.dateDebut.tm_mday == j->dateDuJour.tm_mday && rdvTmp.dateDebut.tm_mon == j->dateDuJour.tm_mon && rdvTmp.dateDebut.tm_year == j->dateDuJour.tm_year) {//la date du rdvTmp est la meme que le premier rdv de la liste.
  47.       struct rdvAgenda *newRdvAgenda;
  48.       struct rdvAgenda *pRdvAgenda;
  49.       struct rdvAgenda *precPRdvAgenda;
  50.       time_t tPRddvAgenda;
  51.       time_t tNewRdvAgenda;
  52.       double diffRdv;
  54.       newRdvAgenda = malloc(sizeof(struct rdvAgenda));
  55.       newRdvAgenda->leRdvAgendaSuivant = malloc(sizeof(struct rdvAgenda));
  56.       pRdvAgenda = malloc(sizeof(struct rdvAgenda));
  57.       pRdvAgenda->leRdvAgendaSuivant = malloc(sizeof(struct rdvAgenda));
  58.       precPRdvAgenda = malloc(sizeof(struct rdvAgenda));
  59.       precPRdvAgenda->leRdvAgendaSuivant = malloc(sizeof(struct rdvAgenda));
  61.       newRdvAgenda->leRdv.dateDebut = rdvTmp.dateDebut;
  62.       newRdvAgenda->leRdv.dateFin = rdvTmp.dateFin;
  63.       strcpy(newRdvAgenda->leRdv.libelle, rdvTmp.libelle);
  65.       pRdvAgenda = p->unRdvAgenda;
  66.       precPRdvAgenda = NULL;
  68.       tPRddvAgenda = mktime(&(pRdvAgenda->leRdv.dateDebut));
  69.       tNewRdvAgenda = mktime(&(newRdvAgenda->leRdv.dateDebut));
  70.      
  71.       diffRdv = difftime(tNewRdvAgenda,tPRddvAgenda);
  74.       while ( diffRdv >= 0 && pRdvAgenda->leRdvAgendaSuivant != NULL ) {
  76. precPRdvAgenda = pRdvAgenda;
  78. pRdvAgenda = pRdvAgenda->leRdvAgendaSuivant;
  80. tPRddvAgenda = mktime(&(pRdvAgenda->leRdv.dateDebut));
  81. diffRdv = difftime(tNewRdvAgenda,tPRddvAgenda);
  83.       }
  84.      
  85.       if ( diffRdv < 0 && precPRdvAgenda == NULL) {//il y a qu'un seul rdvAgenda et il doit se placer apres le rdvTmp.
  88. p->unRdvAgenda = newRdvAgenda;
  89. newRdvAgenda->leRdvAgendaSuivant = pRdvAgenda;
  91.       } else {
  93. if (pRdvAgenda->leRdvAgendaSuivant == NULL) {
  94.  
  95.   pRdvAgenda->leRdvAgendaSuivant = newRdvAgenda;
  96.  
  97. } else {
  98.  
  99.   precPRdvAgenda->leRdvAgendaSuivant = newRdvAgenda;
  100.   newRdvAgenda->leRdvAgendaSuivant = pRdvAgenda;
  101.  
  102. } 
  104.       }
  105.      
  106.       //free(precPRdvAgenda->leRdvAgendaSuivant);
  107.       //free(pRdvAgenda->leRdvAgendaSuivant);
  109.       //free(pRdvAgenda);
  110.       //free(precPRdvAgenda);
  112.       printf("cas spcial au tour : %d\n",i);
  114.     } else {// sinon la date du rdvTmp est avant ou apres la tete de la liste.
  115.    
  116.       time_t tRdvTmp;
  117.       time_t tDateDuJour;
  119.       tRdvTmp = mktime(&(rdvTmp.dateDebut));
  120.       tDateDuJour = mktime(&(p->dateDuJour));
  121.      
  122.       diff = difftime(tRdvTmp,tDateDuJour);
  124.       if ( diff < 0 ) {//le rdvTmp se situe avant le premier jour (tete de la liste) rpertori.
  126. //on cr un nouveau jour, qui sera notre nouvelle tete de liste.
  128. struct jour *newJ;
  130. newJ = malloc(sizeof(struct jour));// allocation de mmoire pour le pointeur sur ma liste.
  131. newJ->unRdvAgenda = malloc(sizeof(struct rdvAgenda));
  132. newJ->jourSuivant = malloc(sizeof(struct jour));
  134. newJ->dateDuJour = rdvTmp.dateDebut;
  135. newJ->jourSuivant = j;
  136. newJ->unRdvAgenda->leRdv.dateDebut = rdvTmp.dateDebut;
  137. newJ->unRdvAgenda->leRdv.dateFin = rdvTmp.dateFin;
  138. strcpy(newJ->unRdvAgenda->leRdv.libelle, rdvTmp.libelle);
  139. newJ->unRdvAgenda->leRdvAgendaSuivant = NULL;
  141. j = newJ;
  144.       } else {//le rdvTmp se situe apres le premier jour (tete de la listerpertori).
  147. while ( diff >= 0 && ( p->dateDuJour.tm_mday != rdvTmp.dateDebut.tm_mday || p->dateDuJour.tm_mon != rdvTmp.dateDebut.tm_mon || p->dateDuJour.tm_year != rdvTmp.dateDebut.tm_year ) && p->jourSuivant != NULL ) {
  149.   //on se place sur le jour le plus appropri.
  151.   precedentP = p;
  152.   p = p->jourSuivant;
  154.   tDateDuJour = mktime(&(p->dateDuJour));
  155.   diff = difftime(tRdvTmp,tDateDuJour);
  157. } 
  159. if ( p->dateDuJour.tm_mday == rdvTmp.dateDebut.tm_mday && p->dateDuJour.tm_mon == rdvTmp.dateDebut.tm_mon && p->dateDuJour.tm_year == rdvTmp.dateDebut.tm_year ) {//il y a un jour deja rpertori pour ce le jour du rdvTmp.
  161.   struct rdvAgenda *newRdvAgenda;
  162.   struct rdvAgenda *pRdvAgenda;
  163.   struct rdvAgenda *precPRdvAgenda;
  164.   time_t tPRddvAgenda;
  165.   time_t tNewRdvAgenda;
  166.   double diffRdv;
  168.   newRdvAgenda = malloc(sizeof(struct rdvAgenda));
  169.   newRdvAgenda->leRdvAgendaSuivant = malloc(sizeof(struct rdvAgenda));
  170.   pRdvAgenda = malloc(sizeof(struct rdvAgenda));
  171.   pRdvAgenda->leRdvAgendaSuivant = malloc(sizeof(struct rdvAgenda));
  172.   precPRdvAgenda = malloc(sizeof(struct rdvAgenda));
  173.   precPRdvAgenda->leRdvAgendaSuivant = malloc(sizeof(struct rdvAgenda));
  174.  
  175.   newRdvAgenda->leRdv.dateDebut = rdvTmp.dateDebut;
  176.   newRdvAgenda->leRdv.dateFin = rdvTmp.dateFin;
  177.   strcpy(newRdvAgenda->leRdv.libelle, rdvTmp.libelle);
  179.   pRdvAgenda = p->unRdvAgenda;
  180.   precPRdvAgenda = NULL;
  181.  
  182.   tPRddvAgenda = mktime(&(pRdvAgenda->leRdv.dateDebut));
  183.   tNewRdvAgenda = mktime(&(newRdvAgenda->leRdv.dateDebut));
  184.  
  185.   diffRdv = difftime(tNewRdvAgenda,tPRddvAgenda);
  186.  
  187.   while ( diffRdv >= 0 && pRdvAgenda->leRdvAgendaSuivant != NULL ) {
  188.    
  189.     precPRdvAgenda = pRdvAgenda;
  190.    
  191.     pRdvAgenda = pRdvAgenda->leRdvAgendaSuivant;
  192.    
  193.     tPRddvAgenda = mktime(&(pRdvAgenda->leRdv.dateDebut));
  194.     diffRdv = difftime(tNewRdvAgenda,tPRddvAgenda);
  195.    
  196.   }
  199.   if ( diffRdv < 0 && precPRdvAgenda == NULL) {//il y a qu'un seul rdvAgenda et il doit se placer apres le rdvTmp.
  202.     p->unRdvAgenda = newRdvAgenda;
  203.     newRdvAgenda->leRdvAgendaSuivant = pRdvAgenda;
  205.   } else {
  207.     if (pRdvAgenda->leRdvAgendaSuivant == NULL) {
  209.       pRdvAgenda->leRdvAgendaSuivant = newRdvAgenda;
  211.     } else {
  213.       precPRdvAgenda->leRdvAgendaSuivant = newRdvAgenda;
  214.       newRdvAgenda->leRdvAgendaSuivant = pRdvAgenda;
  215.  
  216.     } 
  218.   }
  219.   //free(precPRdvAgenda->leRdvAgendaSuivant);
  220.   //free(pRdvAgenda->leRdvAgendaSuivant);
  222.   //free(pRdvAgenda);
  223.   //free(precPRdvAgenda);
  225.  
  226.   printf("cas spcial au tour : %d\n",i);
  227.  
  228. } else {
  229.  
  230.   if (  p->jourSuivant == NULL && diff > 0) {//le rdvTmp tombe sur un jour qui n'est pas rpertori et qui est apres tous les autres rdv de la liste.
  232.     //on cr un nouveau jour, qui sera  la fin de la liste.
  233.    
  234.     struct jour *newJ;
  235.      
  236.  
  237.     newJ = malloc(sizeof(struct jour));// allocation de mmoire pour le pointeur sur ma liste.
  238.     newJ->unRdvAgenda = malloc(sizeof(struct rdvAgenda));
  239.     newJ->jourSuivant = malloc(sizeof(struct jour));
  240.    
  241.    
  242.     newJ->dateDuJour = rdvTmp.dateDebut;
  243.     newJ->jourSuivant = NULL;
  244.     newJ->unRdvAgenda->leRdv.dateDebut = rdvTmp.dateDebut;
  245.     newJ->unRdvAgenda->leRdv.dateFin = rdvTmp.dateFin;
  246.     strcpy(newJ->unRdvAgenda->leRdv.libelle, rdvTmp.libelle);
  247.     newJ->unRdvAgenda->leRdvAgendaSuivant = NULL;
  248.    
  249.     p->jourSuivant = newJ;
  250.    
  251.     p = newJ;
  252.    
  253.   } else {// cas ou il existe forcment des rdv dans liste qui sont avant et apres.
  254.    
  256.     //on cr un nouveau jour, qui sera au milieu de la liste.
  257.             struct jour *newJ;
  258.    
  259.     newJ = malloc(sizeof(struct jour));// allocation de mmoire pour le pointeur sur ma liste.
  260.     newJ->unRdvAgenda = malloc(sizeof(struct rdvAgenda));
  261.     newJ->jourSuivant = malloc(sizeof(struct jour));
  263.     precedentP->jourSuivant = newJ;
  265.     newJ->dateDuJour = rdvTmp.dateDebut;
  266.     newJ->jourSuivant = p;
  268.     newJ->unRdvAgenda->leRdv.dateDebut = rdvTmp.dateDebut;
  269.     newJ->unRdvAgenda->leRdv.dateFin = rdvTmp.dateFin;
  270.     strcpy(newJ->unRdvAgenda->leRdv.libelle, rdvTmp.libelle);
  271.     newJ->unRdvAgenda->leRdvAgendaSuivant = NULL;
  272.    
  273.     p = newJ;
  275.   }
  276.  
  277. }
  278.       }
  280.     }
  283.     if ( !eof() ) {
  284.       readRDV(&rdvTmp,i);//pour pas avoir d'occurence  la fin.
  285.     }
  287.     i++;
  288.   }
  290.   //afficher(j);
  291.  
  292.   closeFile();
  293.  
  294.   free(precedentP->jourSuivant);
  295.   free(p->jourSuivant);
  296.   free(precedentP->unRdvAgenda);
  297.   free(p->unRdvAgenda);
  298.   free(precedentP);
  299.   free(p);
  301.   return j;
  302.  
  303. }

Reply

Marsh Posté le 22-02-2004 à 22:18:16    

khyna a écrit :

Voici la fonction chargeAgenda, ne chambrer pas trop... je débute en C.. :pt1cable:  


Premiere constatation 300 lignes pour une fonction c'est bcp trop, tu m'etonne que tu t'y retrouve pas. T'as certainement des sequences de code recurrente met les sous forme de fonctions plutot que de faire un copier coller bourrin.
 
Deuxieme constatation j'ai vraiment la flemme d'essayer de cherche l'erreur dans ce pave, mais ta fonction au clair.

Reply

Sujets relatifs:

Leave a Replay

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