Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1087 connectés 

  FORUM HardWare.fr
  Programmation
  C

  Passage de pointeurs en paramètre erronés !

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Passage de pointeurs en paramètre erronés !

n°649746
Khyna
Posté le 20-02-2004 à 13:45:37  profilanswer
 

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.

mood
Publicité
Posté le 20-02-2004 à 13:45:37  profilanswer
 

n°649761
cedricbrun
Posté le 20-02-2004 à 13:59:18  profilanswer
 

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
 

n°649768
Khyna
Posté le 20-02-2004 à 14:11:21  profilanswer
 

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

n°651423
chagarou
Posté le 22-02-2004 à 22:18:16  profilanswer
 

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.


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  Passage de pointeurs en paramètre erronés !

 

Sujets relatifs
Peut on appeller un .exe creer en VB avec un parametre ?Parametre template sous forme de chaine de caracteres
[MySql] Requete parametre sur likeAffichage d'un div au passage de la souris
Passage de paramètres avec un callbackpasser un tableau d'entier en parametre dans une URL [resolu]
passage de php/mysql vers php/access : problemes [resolu][VBA] Passer un tableau en parametre de fonction ?
[VB] passer un array en parametre ???[XSLT] Récupération d'un paramètre dans l'URL
Plus de sujets relatifs à : Passage de pointeurs en paramètre erronés !

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.115 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR