Lecture dans un fichier : ligne par ligne

Lecture dans un fichier : ligne par ligne - C++ - Programmation

Marsh Posté le 26-04-2003 à 15:42:28    

Salut,
voilà je dois lire un fichier comprenant des commentaires, en évuitant ces caractères !
Mon fichier à lire se présente sous le forme :  


# ceci est un commentaire
nb_noeuds 10
nb_aretes 20
# encore un commentaire
noeud1 noeuds2 10
noeud1 noeuds2 10
noeud1 noeuds2 10
noeud1 noeuds2 10

et ainsi de suite
 
voilà le code de ma fonction.

Code :
  1. void LireGRAPHE ( char * fic_name , GRAPHE *graphe ) {
  2.   FILE * fichier;
  3.   char tampon[256];
  4.   int test_commentaire;
  5.   int test_noeuds;
  6.   int valeur_recuperee, i;
  7.   char * noeud1;
  8.   char * noeud2;
  9.   int poids_arete;
  10.   int dic_num_n1; /* Le N° retourné par le Dico pour le noeud 1 */
  11.   int dic_num_n2; /* Le N° retourné par le Dico pour le noeud 2 */
  12.  
  13.   fichier = fopen( fic_name , "r" );
  14.   if (fichier==NULL) {
  15.     printf("\nProblème lors de l'acces en lecture du fichier !!\nVous n'avez pas les permissions requises, ou le fichier n'existe pas !!\n" );
  16.     exit (1);
  17.   }
  18.   while ( !feof (fichier) ) {
  19.  
  20.     fscanf ( fichier, "%s", tampon);
  21.  
  22.     test_commentaire = strncmp ( tampon , "#" , 1 );
  23.     if ( test_commentaire != 0 ) { /* on a pas à faire à un commentaire !! */
  24. test_noeuds = strcmp ( tampon , "nbNoeuds" );
  25.       if ( test_noeuds == 0 ) {
  26.         /* On recupere le nombre de noeuds du graphe */
  27.         fscanf ( fichier, "%d", &(graphe->nb_noeuds) );
  28.         /* En théorie, on ne fera celà qu'une fois */
  29.         graphe->tla = (TLA) malloc ( (graphe->nb_noeuds+1) * sizeof ( Liste ));
  30.         if ( graphe->tla == NULL ) {
  31.           fprintf(stderr,"\nProblème lors de l'allocation mémoire du Tla du Graphe !!!\n" );
  32.           exit (1);
  33.         }
  34.         for ( i=1 ; i<=graphe->nb_noeuds ; i++ ) {
  35.           /* On initialise le tla du graphe */
  36.           graphe->tla[i] = CreerVide();       
  37.         }
  38.       }
  39.       else {
  40.         test_noeuds = strcmp ( tampon , "nbArretes" );
  41.         if ( test_noeuds == 0 ) {
  42.           /* On recupere le nombre d'arètes du graphe */
  43.           fscanf ( fichier, "%d", &(graphe->nb_aretes) );
  44.          
  45.           /* Mettons à jours la variable taille du dico */
  46.           graphe->g_dico.taille = graphe->nb_aretes;
  47.          
  48.           /* On va maintenant lancé la création du Dico */
  49.           Construire_Dico ( fichier , &(graphe->g_dico) );
  50.         }
  51.         else { /* Il ne s'agit ni du nb d'aretes, ni du nb de noeuds */
  52.           /* Il s'agit donc d'une ligne du type "noeuds noeuds poids" */
  53.          
  54.           /* Récupération du nom du 1er noeuds */
  55.           fscanf ( fichier, "%s", &noeud1 );
  56.           /* Récupération du nom du 1er noeuds */
  57.           fscanf ( fichier, "%s", &noeud2 );
  58.           /* Récupération du poids de l'arete */
  59.           fscanf ( fichier, "%d", &poids_arete );
  60.          
  61.           /* Il faut récuperer la correspondance des Mots - N° depuis le DICO :: */
  62.           dic_num_n1 = Recup_Num( noeud1 , &(graphe->g_dico) );
  63.           if ( dic_num_n1 == -1 ) {
  64.             printf("\nLe nom du noeud n°1 ne figure pas dans le Dictionnaire !!\n Le programme va s'arreter !!\n" );
  65.             exit (1);
  66.           }
  67.           dic_num_n2 = Recup_Num( noeud2 , &(graphe->g_dico) );
  68.           if ( dic_num_n2 == -1 ) {
  69.             printf("\nLe nom du noeud n°1 ne figure pas dans le Dictionnaire !!\n Le programme va s'arreter !!\n" );
  70.             exit (1);
  71.           }
  73.           /* On met l'arete dans le graphe */
  74.           graphe->tla[dic_num_n1] = Ajoute_GRAPHE ( graphe->tla[dic_num_n1] , dic_num_n2 , poids_arete );
  75.         }
  76.       }
  77.     }
  78.     else { /* sinon, c'est un commentaire et donc on ZAP !! */
  80.       /* Faut lire la ligne entière pour passé à la suivante ! */
  81.       /* Mais on fait comment */
  83.     }
  84.  
  85.  
  86.   }
  87.   /* On a atteint la fin du fichier ! */
  88.   fclose ( fichier );
  89. }

 
 
Voilà, donc je sais faire pour lire une chaine de caractère : fscanf ( fichier, "%s", tampon);
mais celà ne lit qu'une chaine de caractère jusqu'à l'espace ou le retour à la ligne qui la suit !
 
Ce que je voudrais, c'est savoir comment lire une ligne entière !!
En fait quand je lit la 1ere chaine de caract. et que celle là est en fait commence par #, alors c'est un commentaire ; donc je voudrais passer à la ligne suivante !
Comment fait-on ?
 
Merci @+
Miles

Reply

Marsh Posté le 26-04-2003 à 15:42:28   

Reply

Marsh Posté le 26-04-2003 à 15:52:42    

utilise fgets

Code :
  1. while(fgets(tampon, 256, fichier) != NULL)
  2. {
  3. // traiter la ligne
  5. }


 
pour passer les lignes de commantaire il suffite de tester tampon[0] == '#'
 
ca ne marche que si le # est les premier caractère de la ligne. Ca ne marche pas si il y a des espaces avant par exemple.
 

Reply

Marsh Posté le 26-04-2003 à 17:41:56    

et également mauvaise utilisation de feof, ...., fais une recherche sur le forum si tu veux en savoir plus

Reply

Marsh Posté le 26-04-2003 à 19:49:05    

Heu, pour le feof, je vois pas le pb !!
J'ai bien cherché ds le forum, mais ce que j'ai vu semble pareil à ce que j'ai mis !
 
De plus, j'ai mis ceci :
 

Code :
  1. fgets ( tampon, sizeof(tampon) , fichier );

 
Cette ligne de code est traitée si tampon est = au char #
Mon algo tourne de la façon suivante :
je prend la 1ere chaine de caractère du fichier (elle s'arrete au 1er espace rencontré)
je teste si cette chaine commence par un #
  si oui, alors, je lit le reste de la ligne avec le fgets, et je repars au début
  si non  
    je teste si elle est égale à "nb_noeuds"
      si oui, je lit ensuite un entier
      si non
        je teste si elle est égale à "nb_arete"
           si oui je lit ensuite un entier
           si non je lit une chaine de caractère, puis une autre puis un entier
 
Voilà, maintenant ca à l'air de fonctionner !
Je vais faire un debug pas à pas (ce qui n'est pas franchement pratique sous win avec dev-c++)
 
 
merci @+
Miles

Reply

Marsh Posté le 26-04-2003 à 19:50:27    

http://forum.hardware.fr/forum2.ph [...] subcat=386


Message édité par Taz le 26-04-2003 à 19:50:41
Reply

Marsh Posté le 26-04-2003 à 20:56:15    

Merci pour le lien, je viens de le lire, mais ca ne m'éclaire pas des masses !!
Un coup de pousse svp ?
Merci @+
Miles

Reply

Marsh Posté le 26-04-2003 à 22:44:42    

J'ai ca comme code qui marche bien :
 

Code :
  1. /* cette structure contient
  2.    les infos pour une ligne.
  4.    name = nom du champ
  5.    data = recoti la valeur apres lecture.
  6. */
  8. struct CFGField
  9. {
  10.     char* name ;
  11.     char* data ;
  12. };
  14. /* Lecture du fichier config :
  15.    - filename = nom du fichier config à lire
  16.    - CFGInfo = tableau de CFGField decrivant le fichier
  17. */
  19. int read_cfg_file( const char* filename, struct CFGField* CFGInfo )
  20. {
  21.     char  buffer[BUFFERSIZE];
  22.     char* WorkPtr ;
  23.     char* CfgName ;
  24.     char* CfgData ;
  25.     struct CFGField* Cfg ;
  26.     FILE* CfgFile ;
  28.     CfgFile = fopen( filename, "r" );
  29.     /* Tentons d'ouvrir le ficheir de config */
  30.     if( NULL == CfgFile )
  31.     {
  32.         return RETURN_ERR_FOPEN;
  33.     }
  35.     /* Lisons le fichier ligne par ligne */
  36.     while( NULL != fgets( buffer, BUFFERSIZE, CfgFile ))
  37.     {
  38.         /* Si l'on trouve un #, on a un commentaire */
  39.         if( NULL != (WorkPtr = strchr( buffer, '#' )))
  40.         {
  41.           /* On stoppe tout ! */
  42.           *WorkPtr = '\0';
  43.         }
  44.         else
  45.         { 
  46.           /* Sinon on avance */
  47.           WorkPtr = buffer + strlen( buffer );
  48.         }
  50.         WorkPtr--;
  52.         /* Eliminons les espaces superflus de la fin
  53.            de la ligne */
  54.         while( isspace( *WorkPtr ) && WorkPtr >= buffer )
  55.         { *WorkPtr-- = '\0'; }
  56.        
  57.         WorkPtr = buffer;
  58.         while( isspace( *WorkPtr )) WorkPtr++;
  59.        
  60.        /* Si la longeur de la chaine est nulle
  61.           on passe à la ligne suiavnte */
  62.        if( 0 == strlen( WorkPtr )) continue;
  64.         /* Bon cherchons le = qui delimite
  65.            le debut de la valeur du champ */
  67.         CfgName = strtok( WorkPtr, " =" );
  68.         if( NULL != CfgName )
  69.         {
  70.             strlwr( CfgName );
  72.             /* Récupérons la chaine qui se
  73.                trouve APRES le = */
  74.             CfgData = strtok( NULL, "" );
  75.            
  76.             /* Eliminons les espaces superflues */
  77.             while( isspace( *CfgData )) CfgData++;
  78.             if( '=' == *CfgData ) CfgData++;
  79.             while( isspace( *CfgData )) CfgData++;
  81.             /* Cherchons la ligne du tableau
  82.                correspondant au nom de variable
  83.                trouvée
  84.             */
  86.             Cfg = CFGInfo;
  87.             while( NULL != Cfg->name && 0 != strcmp( Cfg->name, CfgName )) Cfg++;
  89.             /* Si notre tableau de description
  90.                n'st pas fini, on copie les données */   
  91.             if( NULL != Cfg->name )
  92.             {
  93.                 Cfg->data = (char*)strdup( CfgData );
  94.                                      
  95.                 if( NULL == Cfg->data )
  96.                 {
  97.                     /* Oops pas assez de memoire */
  98.                     fclose( CfgFile );
  99.                     return RETURN_ERR_MEMORY;
  100.                 }
  101.             }
  102.            
  103.         }   
  104.     }
  105.    
  106.     /* On ferme le fichier et on sort */
  107.     fclose(CfgFile);
  108.     return RETURN_OK;
  109. }


 
Ca lit des fichiers du style
 

Code :
  1. #
  2. # Commentaires
  3. #
  5. variable=10
  6. variable2 = toto.txt
  7. test_du_truc =      1.0f


 
les nom des champs doivent etre en minuscule c'est la seule contrainte.
 
Bon je sais que c pas EXACTEMENT le format mais bon ca peut servir de base.
 
Pour s'en servir :
 

Code :
  1. struct CFGField data[] =
  2. {
  3. {"variable",NULL},
  4. {"variable2",NULL},
  5. {"test_du_truc",NULL},
  6. {NULL,NULL}, /* TRES IMPORTANT */
  7. };
  9. read_cfg( "test.ini", data );
  11. printf("variable = %s\n", data[0].data);


 
Voila avec les commentaires c mieux :P


Message édité par Joel F le 27-04-2003 à 08:58:34
Reply

Marsh Posté le 26-04-2003 à 23:19:02    

Eh Bhé !!!!!!
J'ai rien compris de ton bout de code !!!
Je sais pas comment tu fait pour t'y retrouver, mais pour moi ce n'est que du charabiat !!!
Les noms de variables ne m'inspirent rien du tout !
 
Peut-etre que ca te ferait le même effet si je te montrais mes prog en C, mais là franchement ...  :??:  :??:  :??:  :??:  :??:  
 
Peut-etre qu'avec qq explications ...
 
Mais, bon, je te remerecie quand même !
 
@+
Miles

Reply

Marsh Posté le 27-04-2003 à 08:48:54    

Oops désolé  :pt1cable:  
Je commente tt de suite   :ange:

Reply

Marsh Posté le 27-04-2003 à 13:40:11    

Merci pour tes commentaires,  
ca m'éclaire bien mieux !!
 
Mais, bon c'est un peu compliqué pour moi !
Surtout qu'on a pas vu toutes ces fcts en cours ! ( c'est un projet que je doit faire ! Dijkstra sur un réseau de la stas )
J'ai presque fini de refaire ma fonction, je la poste des que j'ai fini !!!
 
@+
Miles

Reply

Marsh Posté le 27-04-2003 à 13:40:11   

Reply

Marsh Posté le 27-04-2003 à 13:53:13    

Voilà, je pense avoir fini !!
J'ai compiler (sans erreurs), mais pas testé !
 
Voilà le code de ma fonction :

Code :
  1. void LireGRAPHE ( char * fic_name , GRAPHE *graphe ) {
  2.   FILE * fichier;
  3.   char ligne[1024];
  4.   char tampon[256];
  5.   char noeud1[256];
  6.   char noeud2[256];
  7.   int test_commentaire;
  8.   int test_noeuds;
  9.   int valeur_recuperee, i;
  10.   int poids_arete;
  11.   int dic_num_n1; /* Le N° retourné par le Dico pour le noeud 1 */
  12.   int dic_num_n2; /* Le N° retourné par le Dico pour le noeud 2 */
  13.  
  15.  
  16.   fichier = fopen( fic_name , "r" );
  17.   if (fichier==NULL) {
  18.     printf("\nProblème lors de l'acces en lecture du fichier !!\nVous n'avez pas les permissions requises, ou le fichier n'existe pas !!\n" );
  19.     exit (1);
  20.   }
  21.   while( fgets(ligne,1024*sizeof(char),fichier) != NULL) {
  22.     /* histoire de pas lire 2 fois le meme caractere ;) */
  23.  
  24.     if (ligne[0] != '#') {
  25.       /* Ce n'est pas une ligne de commentaire !! */
  26.       /* On va traiter la ligne lue */
  27.       sscanf( ligne , "%s " , tampon );
  28.       if ( strcmp(tampon,"nb_noeud" ) == 0) {
  29.         /* traitenement si nb_noeud */
  30.         sscanf( ligne+strlen(tampon)+1 , "%d" , &(graphe->nb_noeuds) );
  31.         graphe->tla = (TLA) malloc ( (graphe->nb_noeuds+1) * sizeof ( Liste ));
  32.         if ( graphe->tla == NULL ) {
  33.           fprintf(stderr,"\nProblème lors de l'allocation mémoire du Tla du Graphe !!!\n" );
  34.           exit (1);
  35.         }
  36.         for ( i=1 ; i<=graphe->nb_noeuds ; i++ ) {
  37.           /* On initialise le tla du graphe */
  38.           graphe->tla[i] = CreerVide();       
  39.         }
  40.       }
  41.       else {
  42.         if ( strcmp(ligne,"nb_arete" ) == 0) {
  43.           /* traitenement si nb_arete */
  44.           sscanf( ligne+strlen(tampon)+1 , "%d" , &(graphe->nb_aretes) );
  45.          
  46.           /* Mettons à jours la variable taille du dico */
  47.           graphe->g_dico.taille = graphe->nb_noeuds;
  48.          
  49.           /* On va maintenant lancé la création du Dico */
  50.           Construire_Dico ( fichier , &(graphe->g_dico) );
  51.          
  52.         }
  53.         else {
  54.           /* traitenement sinon */
  55.           /* cad que l'on doit lire 2 chaines de caract l'une */
  56.           /* à la suite de l'autre, et apres un entier */
  57.           sscanf( ligne , "%s %s %d" , noeud1 , noeud2 , &poids_arete );
  58.          
  59.           /* Il faut récuperer la correspondance des Mots - N° depuis le DICO :: */
  60.           dic_num_n1 = Recup_Num( noeud1 , &(graphe->g_dico) );
  61.           if ( dic_num_n1 == -1 ) {
  62.             printf("\nLe nom du noeud n°1 ne figure pas dans le Dictionnaire !!\n Le programme va s'arreter !!\n" );
  63.             exit (1);
  64.           }
  65.           dic_num_n2 = Recup_Num( noeud2 , &(graphe->g_dico) );
  66.           if ( dic_num_n2 == -1 ) {
  67.             printf("\nLe nom du noeud n°1 ne figure pas dans le Dictionnaire !!\n Le programme va s'arreter !!\n" );
  68.             exit (1);
  69.           }
  71.           /* On met l'arete dans le graphe */
  72.           graphe->tla[dic_num_n1] = Ajoute_GRAPHE ( graphe->tla[dic_num_n1] , dic_num_n2 , poids_arete );
  73.          
  74.         }
  75.       }
  76.     }
  77.     /* sinon c'est une ligne de commentaire !! */
  78.     /* et repart au début, lire une autre ligne */
  79.   }
  80.   /* On a atteint la fin du fichier ! */
  81.   fclose ( fichier );
  82. }


 
UNe explication des diverses fonctions non explicitées que j'appelle :
- Construire_Dico : va me contruire un dictionnaire avec mes nom de noeuds associés à un N°
- Ajoute_GRAPHE : va ajouter une arete au graphe tq A = ( S1 , S2, Pds )
 
voilà les différentes structures utilisées :

Code :
  1. struct dico {
  2.   char ** tab; /* Un tableau de ptr sur des char * */
  3.   int taille;  /* taille du tableau */
  4.   int nb_mots; /* nombre de mots dans le dico */
  5. };
  7. typedef struct dico DICO;
  10. struct elementliste {
  11.   int valeur; /* Evident !! */
  12.   int poids; /* Poids sur l'arète */
  13.   struct elementliste *suivant; /* Pointeur sur un elementliste */
  14.                                 /* désignant l'elt suivant      */
  15. };
  17. typedef struct elementliste ElementListe, *Liste;
  19. typedef Liste *TLA;
  21. /* La structure pour le Graphe */
  22. struct s_graphe {
  23.   TLA tla; /* le tla */
  24.   int nb_noeuds;  /* le nb de noeuds du graphe    */
  25.                   /* aussi appelés sommets        */
  26.   int nb_aretes;  /* le nb d'aretes du graphe     */
  27.   DICO g_dico;    /* le dico necessaire au graphe */
  28. };
  30. typedef struct s_graphe GRAPHE;
  32. struct elementtas {
  33.   int poids_noeud;
  34.   ElementListe * elt_tas;
  35. };
  37. typedef struct elementtas ElementTAS;
  39. struct s_tas {
  40.   ElementTAS** tab; /* Un tableau de pointeurs sur des ElementListe */
  41.   int nb_elt;         /* nb d'elt à prendre en compte dans le tas */
  42.   int taille;         /* nb total d'elt du tas (le max) */
  43. };
  45. typedef struct s_tas TAS;

 
Bon c'est peut-être pas dans le bon ordre pour que ca fonctionne, mais du pts de vue de mes includes, c'est OK ! J'ai juste mis en vrac !!
 
Voilà, merci de votre aide,
 
AU fait, est-ce correct ?
 
 
[edit]
au fait, voilà le code de la fonction qui me cree le dico :

Code :
  1. void Construire_Dico ( FILE * fichier , DICO * Le_Dico ) {
  2.   char tampon[256];
  3.   int fini=0;
  4.   int test_fin;
  5.   int i; /* servira d'indexeur pour l'elt à ajouter dans le tableau du dico */
  7.   Le_Dico->nb_mots = 0;
  8.   /* ON alloue l'espace mémoire necessaire au dico */
  9.   Le_Dico->tab = (char **) malloc ((Le_Dico->taille+1) * sizeof (char *));
  10.   if ( Le_Dico->tab == NULL ) {
  11.     fprintf (stderr,"Erreur lors de l'allocation mémoire pour le tableau du dico !! " );
  12.     exit (1);
  13.   }
  15.   i = 1; /* on commence l'indexation à 1 */
  16.  
  17.   /* on arrete de lire les aretes qd on atteindra la ligne "###l.ligne.01.txt.arete" */
  18.   /* Qd on atteindra cette ligne, fini passera à 1 !! */
  19.   while ( fini==0 ) {
  20.     test_fin = strncmp ( tampon , "###" , 3 );
  21.     if ( test_fin == 0 ) { /* C'est la fin de la lecture du dico */
  22.       fini = 1;
  23.     }
  24.     else {
  25.       fscanf ( fichier , "%s" , &tampon );
  26.       Le_Dico->tab[i] = (char *) strdup (tampon);
  27.       i++; /* pour passer à l'elt suivant */
  28.       Le_Dico->nb_mots++;
  29.     }
  30.  
  31.   }
  32. }

 
Est-ce que avec la méthode de lecture du fichier faite dans LireGRAPHE, celle de Construire_DICO va marcher ?
[/edit]
 
@+
Miles


Message édité par Miles--Teg le 27-04-2003 à 14:00:05
Reply

Sujets relatifs:

Leave a Replay

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