Tema: Lectura de archivo en C++
Ver Mensaje Individual
  #6 (permalink)  
Antiguo 16/12/2012, 09:40
kelvi
 
Fecha de Ingreso: diciembre-2012
Mensajes: 13
Antigüedad: 12 años
Puntos: 0
Respuesta: Lectura de archivo en C++
Gracias de nuevo Vosk,

No acabo de entender esta parte:

".. Si lo haces así recuerda que para finalizar no hay suficiente con llista.clear() (que por cierto te lo has dejado), tendrás que recorrer todos los elementos para hacer delete[]cO y al final llista.clear().."

Estaría agradecido si pudieras comentarme-lo de otra forma a ver si lo pillo jejeje

He vuelto a aplicar cambios y ahora tengo lo siguiente:

Código C++: 
Ver original
  1. #include <iostream>
  2. #include <iomanip>
  3. #include <fstream>
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <list>
  8.  
  9. using namespace std;
  10.  
  11. typedef struct {
  12.     char EV;
  13.     float T;
  14.     int E,R;
  15.     string P;
  16.     float G;
  17.     string FLA;
  18.     int FLU;
  19.     char *O,*D;
  20.     float S,I;
  21. } DADES_ARXIU;
  22.  
  23. enum ID_CAMPS{EV,T,E,R,P,G,FLA,FLU,O,D,S,I};
  24.  
  25. int main() {
  26.     list <DADES_ARXIU> llista;
  27.     DADES_ARXIU camps;
  28.     DADES_ARXIU zero = {0};
  29.     int camp;//incremental
  30.     char * pch;
  31.     string linia;
  32.     //FITXER DE LECTURA 
  33.     ifstream fitxer;
  34.     fitxer.open("TCL/out.tr");
  35.     if (!fitxer) {
  36.         cerr << "Error al llegir fitxer";
  37.         return 1;
  38.     }
  39.  
  40.     while(getline(fitxer,linia)){   
  41.     
  42.         camp = EV;
  43.         pch = strtok((char*)linia.c_str(), " ");
  44.         while(pch != NULL){
  45.             switch(camp) {
  46.                 case EV: {                  
  47.                                 camps.EV = pch[0];
  48.                         }break;
  49.                 case T: {
  50.                     camps.T = atof(pch);                    
  51.                 }break;
  52.                 case E: {
  53.                     camps.E = atoi(pch);                    
  54.                         }break;
  55.                 case R: {
  56.                     camps.R = atoi(pch);                    
  57.                 }break;
  58.                 case P: {
  59.                     camps.P = pch;                    
  60.                         }break;
  61.                 case G: {
  62.                     camps.G = atof(pch);                   
  63.                 }break;
  64.                 case FLA: {
  65.                     camps.FLA = pch;                
  66.                         }break;
  67.                 case FLU: {
  68.                     camps.FLU = atoi(pch);       
  69.                 }break;
  70.                 case O: {
  71.                     //camps.O = new char[strlen(pch)];
  72.                     //memcpy(camps.O,pch,strlen(pch));                  
  73.                         }break;
  74.                 case D: {
  75.                     //camps.D = new char[strlen(pch)];
  76.                     //memcpy(camps.D,pch,strlen(pch));                    
  77.                 }break;
  78.                 case S: {
  79.                     camps.S = atoi(pch);                    
  80.                         }break;
  81.                 case I: {
  82.                     camps.I = atoi(pch);                    
  83.                 }break;
  84.             }
  85.             pch = strtok (NULL, " ");
  86.             camp++;
  87.         }
  88.     if(camp != I+1){ cout << "ERROR DE FITXER"; return 1;}
  89.     llista.push_back (camps);
  90.     //VACIAR STRUCT
  91.     camps = zero;
  92.     }
  93.     fitxer.close();
  94.     llista.clear();
  95.     return 0;
  96. }

La parte de vaciar el struct en cada repetición del bucle no estoy muy seguro si lo hace bien pero la intención es que así lo haga.

Un Saludo,
Fran